encoders ¶

FFmpeg encoders.

Functions:

Name	Description
`a64multi`	(codec a64_multi)
`a64multi5`	(codec a64_multi5)
`aac`	Args:
`ac3`	Args:
`ac3_fixed`	(codec ac3)
`adpcm_adx`	Returns:
`adpcm_argo`	Args:
`adpcm_ima_alp`	Args:
`adpcm_ima_amv`	Args:
`adpcm_ima_apm`	Args:
`adpcm_ima_qt`	Args:
`adpcm_ima_ssi`	Args:
`adpcm_ima_wav`	Args:
`adpcm_ima_ws`	Args:
`adpcm_ms`	Args:
`adpcm_swf`	Args:
`adpcm_yamaha`	Args:
`alac`	Args:
`alias_pix`	Returns:
`amv`	Args:
`anull`	Returns:
`apng`	Args:
`aptx`	Returns:
`aptx_hd`	Returns:
`ass`	Returns:
`asv1`	Returns:
`asv2`	Returns:
`av1_vaapi`	(codec av1)
`avrp`	Returns:
`avui`	Returns:
`ayuv`	Returns:
`bitpacked`	Returns:
`bmp`	Returns:
`cfhd`	Args:
`cinepak`	Args:
`cljr`	Args:
`comfortnoise`	Returns:
`dca`	(codec dts)
`dfpwm`	Returns:
`dnxhd`	Args:
`dpx`	Returns:
`dvbsub`	(codec dvb_subtitle)
`dvdsub`	(codec dvd_subtitle)
`dvvideo`	Args:
`eac3`	Args:
`exr`	Args:
`ffv1`	Args:
`ffvhuff`	Args:
`fits`	Returns:
`flac`	Args:
`flashsv`	Returns:
`flashsv2`	Returns:
`flv`	(codec flv1)
`g722`	(codec adpcm_g722)
`g723_1`	Returns:
`g726`	(codec adpcm_g726)
`g726le`	(codec adpcm_g726le)
`gif`	Args:
`h261`	Args:
`h263`	Args:
`h263_v4l2m2m`	(codec h263)
`h263p`	Args:
`h264_v4l2m2m`	(codec h264)
`h264_vaapi`	(codec h264)
`hdr`	Returns:
`hevc_v4l2m2m`	(codec hevc)
`hevc_vaapi`	(codec hevc)
`huffyuv`	Args:
`jpeg2000`	Args:
`jpegls`	Args:
`libfdk_aac`	(codec aac)
`libkvazaar`	(codec hevc)
`libmp3lame`	(codec mp3)
`libopencore_amrnb`	(codec amr_nb)
`libopenjpeg`	(codec jpeg2000)
`libopus`	(codec opus)
`libsvtav1`	(codec av1)
`libtheora`	(codec theora)
`libvorbis`	(codec vorbis)
`libvpx`	(codec vp8)
`libwebp`	(codec webp)
`libwebp_anim`	(codec webp)
`libx264`	(codec h264)
`libx264rgb`	(codec h264)
`libx265`	(codec hevc)
`libxvid`	(codec mpeg4)
`ljpeg`	Args:
`magicyuv`	Args:
`mjpeg`	Args:
`mjpeg_vaapi`	(codec mjpeg)
`mlp`	Args:
`mov_text`	Args:
`mp2`	Returns:
`mp2fixed`	(codec mp2)
`mpeg1video`	Args:
`mpeg2_vaapi`	(codec mpeg2video)
`mpeg2video`	Args:
`mpeg4`	Args:
`mpeg4_v4l2m2m`	(codec mpeg4)
`msmpeg4`	(codec msmpeg4v3)
`msmpeg4v2`	Args:
`msrle`	Returns:
`msvideo1`	Returns:
`nellymoser`	Returns:
`opus`	Args:
`pam`	Returns:
`pbm`	Returns:
`pcm_alaw`	Returns:
`pcm_bluray`	Returns:
`pcm_dvd`	Returns:
`pcm_f32be`	Returns:
`pcm_f32le`	Returns:
`pcm_f64be`	Returns:
`pcm_f64le`	Returns:
`pcm_mulaw`	Returns:
`pcm_s16be`	Returns:
`pcm_s16be_planar`	Returns:
`pcm_s16le`	Returns:
`pcm_s16le_planar`	Returns:
`pcm_s24be`	Returns:
`pcm_s24daud`	Returns:
`pcm_s24le`	Returns:
`pcm_s24le_planar`	Returns:
`pcm_s32be`	Returns:
`pcm_s32le`	Returns:
`pcm_s32le_planar`	Returns:
`pcm_s64be`	Returns:
`pcm_s64le`	Returns:
`pcm_s8`	Returns:
`pcm_s8_planar`	Returns:
`pcm_u16be`	Returns:
`pcm_u16le`	Returns:
`pcm_u24be`	Returns:
`pcm_u24le`	Returns:
`pcm_u32be`	Returns:
`pcm_u32le`	Returns:
`pcm_u8`	Returns:
`pcm_vidc`	Returns:
`pcx`	Returns:
`pfm`	Returns:
`pgm`	Returns:
`pgmyuv`	Returns:
`phm`	Returns:
`png`	Args:
`ppm`	Returns:
`prores`	Args:
`prores_aw`	(codec prores)
`prores_ks`	(codec prores)
`qoi`	Returns:
`qtrle`	Returns:
`r10k`	Returns:
`r210`	Returns:
`rawvideo`	Returns:
`real_144`	(codec ra_144)
`roq_dpcm`	Returns:
`roqvideo`	(codec roq)
`rpza`	Args:
`rv10`	Args:
`rv20`	Args:
`s302m`	Returns:
`sbc`	Args:
`sgi`	Args:
`smc`	Returns:
`snow`	Args:
`sonic`	Returns:
`sonicls`	Returns:
`speedhq`	Args:
`srt`	(codec subrip)
`ssa`	(codec ass)
`subrip`	Returns:
`sunrast`	Args:
`svq1`	Args:
`targa`	Args:
`text`	Returns:
`tiff`	Args:
`truehd`	Args:
`tta`	Returns:
`ttml`	Returns:
`utvideo`	Args:
`v210`	Returns:
`v308`	Returns:
`v408`	Returns:
`v410`	Returns:
`vbn`	Args:
`vc2`	(codec dirac)
`vnull`	Returns:
`vorbis`	Returns:
`vp8_v4l2m2m`	(codec vp8)
`vp8_vaapi`	(codec vp8)
`vp9_vaapi`	(codec vp9)
`wavpack`	Args:
`wbmp`	Returns:
`webvtt`	Returns:
`wmav1`	Returns:
`wmav2`	Returns:
`wmv1`	Args:
`wmv2`	Args:
`wrapped_avframe`	Returns:
`xbm`	Returns:
`xface`	Returns:
`xsub`	Returns:
`xwd`	Returns:
`y41p`	Returns:
`yuv4`	Returns:
`zlib`	Returns:
`zmbv`	Returns:

a64multi ¶

a64multi() -> FFMpegEncoderOption

(codec a64_multi)

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

a64multi5 ¶

a64multi5() -> FFMpegEncoderOption

(codec a64_multi5)

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

aac ¶

aac(
    aac_coder: (
        int | None | Literal["anmr", "twoloop", "fast"]
    ) = None,
    aac_ms: bool | None = None,
    aac_is: bool | None = None,
    aac_pns: bool | None = None,
    aac_tns: bool | None = None,
    aac_ltp: bool | None = None,
    aac_pred: bool | None = None,
    aac_pce: bool | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`aac_coder`	`int \| None \| Literal['anmr', 'twoloop', 'fast']`	Coding algorithm (from 0 to 2) (default twoloop)	`None`
`aac_ms`	`bool \| None`	Force M/S stereo coding (default auto)	`None`
`aac_is`	`bool \| None`	Intensity stereo coding (default true)	`None`
`aac_pns`	`bool \| None`	Perceptual noise substitution (default true)	`None`
`aac_tns`	`bool \| None`	Temporal noise shaping (default true)	`None`
`aac_ltp`	`bool \| None`	Long term prediction (default false)	`None`
`aac_pred`	`bool \| None`	AAC-Main prediction (default false)	`None`
`aac_pce`	`bool \| None`	Forces the use of PCEs (default false)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

ac3 ¶

ac3(
    center_mixlev: float | None = None,
    surround_mixlev: float | None = None,
    mixing_level: int | None = None,
    room_type: (
        int
        | None
        | Literal["notindicated", "large", "small"]
    ) = None,
    per_frame_metadata: bool | None = None,
    copyright: int | None = None,
    dialnorm: int | None = None,
    dsur_mode: (
        int | None | Literal["notindicated", "on", "off"]
    ) = None,
    original: int | None = None,
    dmix_mode: (
        int
        | None
        | Literal["notindicated", "ltrt", "loro", "dplii"]
    ) = None,
    ltrt_cmixlev: float | None = None,
    ltrt_surmixlev: float | None = None,
    loro_cmixlev: float | None = None,
    loro_surmixlev: float | None = None,
    dsurex_mode: (
        int
        | None
        | Literal["notindicated", "on", "off", "dpliiz"]
    ) = None,
    dheadphone_mode: (
        int | None | Literal["notindicated", "on", "off"]
    ) = None,
    ad_conv_type: (
        int | None | Literal["standard", "hdcd"]
    ) = None,
    stereo_rematrixing: bool | None = None,
    channel_coupling: int | None | Literal["auto"] = None,
    cpl_start_band: int | None | Literal["auto"] = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`center_mixlev`	`float \| None`	Center Mix Level (from 0 to 1) (default 0.594604)	`None`
`surround_mixlev`	`float \| None`	Surround Mix Level (from 0 to 1) (default 0.5)	`None`
`mixing_level`	`int \| None`	Mixing Level (from -1 to 111) (default -1)	`None`
`room_type`	`int \| None \| Literal['notindicated', 'large', 'small']`	Room Type (from -1 to 2) (default -1)	`None`
`per_frame_metadata`	`bool \| None`	Allow Changing Metadata Per-Frame (default false)	`None`
`copyright`	`int \| None`	Copyright Bit (from -1 to 1) (default -1)	`None`
`dialnorm`	`int \| None`	Dialogue Level (dB) (from -31 to -1) (default -31)	`None`
`dsur_mode`	`int \| None \| Literal['notindicated', 'on', 'off']`	Dolby Surround Mode (from -1 to 2) (default -1)	`None`
`original`	`int \| None`	Original Bit Stream (from -1 to 1) (default -1)	`None`
`dmix_mode`	`int \| None \| Literal['notindicated', 'ltrt', 'loro', 'dplii']`	Preferred Stereo Downmix Mode (from -1 to 3) (default -1)	`None`
`ltrt_cmixlev`	`float \| None`	Lt/Rt Center Mix Level (from -1 to 2) (default -1)	`None`
`ltrt_surmixlev`	`float \| None`	Lt/Rt Surround Mix Level (from -1 to 2) (default -1)	`None`
`loro_cmixlev`	`float \| None`	Lo/Ro Center Mix Level (from -1 to 2) (default -1)	`None`
`loro_surmixlev`	`float \| None`	Lo/Ro Surround Mix Level (from -1 to 2) (default -1)	`None`
`dsurex_mode`	`int \| None \| Literal['notindicated', 'on', 'off', 'dpliiz']`	Dolby Surround EX Mode (from -1 to 3) (default -1)	`None`
`dheadphone_mode`	`int \| None \| Literal['notindicated', 'on', 'off']`	Dolby Headphone Mode (from -1 to 2) (default -1)	`None`
`ad_conv_type`	`int \| None \| Literal['standard', 'hdcd']`	A/D Converter Type (from -1 to 1) (default -1)	`None`
`stereo_rematrixing`	`bool \| None`	Stereo Rematrixing (default true)	`None`
`channel_coupling`	`int \| None \| Literal['auto']`	Channel Coupling (from -1 to 1) (default auto)	`None`
`cpl_start_band`	`int \| None \| Literal['auto']`	Coupling Start Band (from -1 to 15) (default auto)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

ac3_fixed ¶

ac3_fixed(
    center_mixlev: float | None = None,
    surround_mixlev: float | None = None,
    mixing_level: int | None = None,
    room_type: (
        int
        | None
        | Literal["notindicated", "large", "small"]
    ) = None,
    per_frame_metadata: bool | None = None,
    copyright: int | None = None,
    dialnorm: int | None = None,
    dsur_mode: (
        int | None | Literal["notindicated", "on", "off"]
    ) = None,
    original: int | None = None,
    dmix_mode: (
        int
        | None
        | Literal["notindicated", "ltrt", "loro", "dplii"]
    ) = None,
    ltrt_cmixlev: float | None = None,
    ltrt_surmixlev: float | None = None,
    loro_cmixlev: float | None = None,
    loro_surmixlev: float | None = None,
    dsurex_mode: (
        int
        | None
        | Literal["notindicated", "on", "off", "dpliiz"]
    ) = None,
    dheadphone_mode: (
        int | None | Literal["notindicated", "on", "off"]
    ) = None,
    ad_conv_type: (
        int | None | Literal["standard", "hdcd"]
    ) = None,
    stereo_rematrixing: bool | None = None,
    channel_coupling: int | None | Literal["auto"] = None,
    cpl_start_band: int | None | Literal["auto"] = None,
) -> FFMpegEncoderOption

(codec ac3)

Parameters:

Name	Type	Description	Default
`center_mixlev`	`float \| None`	Center Mix Level (from 0 to 1) (default 0.594604)	`None`
`surround_mixlev`	`float \| None`	Surround Mix Level (from 0 to 1) (default 0.5)	`None`
`mixing_level`	`int \| None`	Mixing Level (from -1 to 111) (default -1)	`None`
`room_type`	`int \| None \| Literal['notindicated', 'large', 'small']`	Room Type (from -1 to 2) (default -1)	`None`
`per_frame_metadata`	`bool \| None`	Allow Changing Metadata Per-Frame (default false)	`None`
`copyright`	`int \| None`	Copyright Bit (from -1 to 1) (default -1)	`None`
`dialnorm`	`int \| None`	Dialogue Level (dB) (from -31 to -1) (default -31)	`None`
`dsur_mode`	`int \| None \| Literal['notindicated', 'on', 'off']`	Dolby Surround Mode (from -1 to 2) (default -1)	`None`
`original`	`int \| None`	Original Bit Stream (from -1 to 1) (default -1)	`None`
`dmix_mode`	`int \| None \| Literal['notindicated', 'ltrt', 'loro', 'dplii']`	Preferred Stereo Downmix Mode (from -1 to 3) (default -1)	`None`
`ltrt_cmixlev`	`float \| None`	Lt/Rt Center Mix Level (from -1 to 2) (default -1)	`None`
`ltrt_surmixlev`	`float \| None`	Lt/Rt Surround Mix Level (from -1 to 2) (default -1)	`None`
`loro_cmixlev`	`float \| None`	Lo/Ro Center Mix Level (from -1 to 2) (default -1)	`None`
`loro_surmixlev`	`float \| None`	Lo/Ro Surround Mix Level (from -1 to 2) (default -1)	`None`
`dsurex_mode`	`int \| None \| Literal['notindicated', 'on', 'off', 'dpliiz']`	Dolby Surround EX Mode (from -1 to 3) (default -1)	`None`
`dheadphone_mode`	`int \| None \| Literal['notindicated', 'on', 'off']`	Dolby Headphone Mode (from -1 to 2) (default -1)	`None`
`ad_conv_type`	`int \| None \| Literal['standard', 'hdcd']`	A/D Converter Type (from -1 to 1) (default -1)	`None`
`stereo_rematrixing`	`bool \| None`	Stereo Rematrixing (default true)	`None`
`channel_coupling`	`int \| None \| Literal['auto']`	Channel Coupling (from -1 to 1) (default auto)	`None`
`cpl_start_band`	`int \| None \| Literal['auto']`	Coupling Start Band (from -1 to 15) (default auto)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

adpcm_adx ¶

adpcm_adx() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

adpcm_argo ¶

adpcm_argo(
    block_size: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`block_size`	`int \| None`	set the block size (from 32 to 8192) (default 1024)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

adpcm_ima_alp ¶

adpcm_ima_alp(
    block_size: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`block_size`	`int \| None`	set the block size (from 32 to 8192) (default 1024)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

adpcm_ima_amv ¶

adpcm_ima_amv(
    block_size: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`block_size`	`int \| None`	set the block size (from 32 to 8192) (default 1024)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

adpcm_ima_apm ¶

adpcm_ima_apm(
    block_size: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`block_size`	`int \| None`	set the block size (from 32 to 8192) (default 1024)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

adpcm_ima_qt ¶

adpcm_ima_qt(
    block_size: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`block_size`	`int \| None`	set the block size (from 32 to 8192) (default 1024)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

adpcm_ima_ssi ¶

adpcm_ima_ssi(
    block_size: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`block_size`	`int \| None`	set the block size (from 32 to 8192) (default 1024)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

adpcm_ima_wav ¶

adpcm_ima_wav(
    block_size: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`block_size`	`int \| None`	set the block size (from 32 to 8192) (default 1024)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

adpcm_ima_ws ¶

adpcm_ima_ws(
    block_size: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`block_size`	`int \| None`	set the block size (from 32 to 8192) (default 1024)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

adpcm_ms ¶

adpcm_ms(
    block_size: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`block_size`	`int \| None`	set the block size (from 32 to 8192) (default 1024)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

adpcm_swf ¶

adpcm_swf(
    block_size: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`block_size`	`int \| None`	set the block size (from 32 to 8192) (default 1024)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

adpcm_yamaha ¶

adpcm_yamaha(
    block_size: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`block_size`	`int \| None`	set the block size (from 32 to 8192) (default 1024)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

alac ¶

alac(
    min_prediction_order: int | None = None,
    max_prediction_order: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`min_prediction_order`	`int \| None`	(from 1 to 30) (default 4)	`None`
`max_prediction_order`	`int \| None`	(from 1 to 30) (default 6)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

alias_pix ¶

alias_pix() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

amv ¶

amv(
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    huffman: (
        int | None | Literal["default", "optimal"]
    ) = None,
    force_duplicated_matrix: bool | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`huffman`	`int \| None \| Literal['default', 'optimal']`	Huffman table strategy (from 0 to 1) (default optimal)	`None`
`force_duplicated_matrix`	`bool \| None`	Always write luma and chroma matrix for mjpeg, useful for rtp streaming. (default false)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

anull ¶

anull() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

apng ¶

apng(
    dpi: int | None = None,
    dpm: int | None = None,
    pred: (
        int
        | None
        | Literal[
            "none", "sub", "up", "avg", "paeth", "mixed"
        ]
    ) = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`dpi`	`int \| None`	Set image resolution (in dots per inch) (from 0 to 65536) (default 0)	`None`
`dpm`	`int \| None`	Set image resolution (in dots per meter) (from 0 to 65536) (default 0)	`None`
`pred`	`int \| None \| Literal['none', 'sub', 'up', 'avg', 'paeth', 'mixed']`	Prediction method (from 0 to 5) (default none)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

aptx ¶

aptx() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

aptx_hd ¶

aptx_hd() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

ass ¶

ass() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

asv1 ¶

asv1() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

asv2 ¶

asv2() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

av1_vaapi ¶

av1_vaapi(
    low_power: bool | None = None,
    idr_interval: int | None = None,
    b_depth: int | None = None,
    async_depth: int | None = None,
    max_frame_size: int | None = None,
    rc_mode: (
        int
        | None
        | Literal[
            "auto",
            "CQP",
            "CBR",
            "VBR",
            "ICQ",
            "QVBR",
            "AVBR",
        ]
    ) = None,
    profile: (
        int | None | Literal["main", "high", "professional"]
    ) = None,
    tier: int | None | Literal["main", "high"] = None,
    level: (
        int
        | None
        | Literal[
            "2.0",
            "2.1",
            "3.0",
            "3.1",
            "4.0",
            "4.1",
            "5.0",
            "5.1",
            "5.2",
            "5.3",
            "6.0",
            "6.1",
            "6.2",
            "6.3",
        ]
    ) = None,
    tiles: str | None = None,
    tile_groups: int | None = None,
) -> FFMpegEncoderOption

(codec av1)

Parameters:

Name	Type	Description	Default
`low_power`	`bool \| None`	Use low-power encoding mode (only available on some platforms; may not support all encoding features) (default false)	`None`
`idr_interval`	`int \| None`	Distance (in I-frames) between IDR frames (from 0 to INT_MAX) (default 0)	`None`
`b_depth`	`int \| None`	Maximum B-frame reference depth (from 1 to INT_MAX) (default 1)	`None`
`async_depth`	`int \| None`	Maximum processing parallelism. Increase this to improve single channel performance. This option doesn't work if driver doesn't implement vaSyncBuffer function. (from 1 to 64) (default 2)	`None`
`max_frame_size`	`int \| None`	Maximum frame size (in bytes) (from 0 to INT_MAX) (default 0)	`None`
`rc_mode`	`int \| None \| Literal['auto', 'CQP', 'CBR', 'VBR', 'ICQ', 'QVBR', 'AVBR']`	Set rate control mode (from 0 to 6) (default auto)	`None`
`profile`	`int \| None \| Literal['main', 'high', 'professional']`	Set profile (seq_profile) (from -99 to 255) (default -99)	`None`
`tier`	`int \| None \| Literal['main', 'high']`	Set tier (seq_tier) (from 0 to 1) (default main)	`None`
`level`	`int \| None \| Literal['2.0', '2.1', '3.0', '3.1', '4.0', '4.1', '5.0', '5.1', '5.2', '5.3', '6.0', '6.1', '6.2', '6.3']`	Set level (seq_level_idx) (from -99 to 31) (default -99)	`None`
`tiles`	`str \| None`	Tile columns x rows (Use minimal tile column/row number automatically by default)	`None`
`tile_groups`	`int \| None`	Number of tile groups for encoding (from 1 to 4096) (default 1)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

avrp ¶

avrp() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

avui ¶

avui() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

ayuv ¶

ayuv() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

bitpacked ¶

bitpacked() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

bmp ¶

bmp() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

cfhd ¶

cfhd(
    quality: (
        int
        | None
        | Literal[
            "film3+",
            "film3",
            "film2+",
            "film2",
            "film1.5",
            "film1+",
            "film1",
            "high+",
            "high",
            "medium+",
            "medium",
            "low+",
            "low",
        ]
    ) = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`quality`	`int \| None \| Literal['film3+', 'film3', 'film2+', 'film2', 'film1.5', 'film1+', 'film1', 'high+', 'high', 'medium+', 'medium', 'low+', 'low']`	set quality (from 0 to 12) (default film3+)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

cinepak ¶

cinepak(
    max_extra_cb_iterations: int | None = None,
    skip_empty_cb: bool | None = None,
    max_strips: int | None = None,
    min_strips: int | None = None,
    strip_number_adaptivity: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`max_extra_cb_iterations`	`int \| None`	Max extra codebook recalculation passes, more is better and slower (from 0 to INT_MAX) (default 2)	`None`
`skip_empty_cb`	`bool \| None`	Avoid wasting bytes, ignore vintage MacOS decoder (default false)	`None`
`max_strips`	`int \| None`	Limit strips/frame, vintage compatible is 1..3, otherwise the more the better (from 1 to 32) (default 3)	`None`
`min_strips`	`int \| None`	Enforce min strips/frame, more is worse and faster, must be <= max_strips (from 1 to 32) (default 1)	`None`
`strip_number_adaptivity`	`int \| None`	How fast the strip number adapts, more is slightly better, much slower (from 0 to 31) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

cljr ¶

cljr(dither_type: int | None = None) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`dither_type`	`int \| None`	Dither type (from 0 to 2) (default 1)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

comfortnoise ¶

comfortnoise() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

dca ¶

dca(dca_adpcm: bool | None = None) -> FFMpegEncoderOption

(codec dts)

Parameters:

Name	Type	Description	Default
`dca_adpcm`	`bool \| None`	Use ADPCM encoding (default false)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

dfpwm ¶

dfpwm() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

dnxhd ¶

dnxhd(
    nitris_compat: bool | None = None,
    ibias: int | None = None,
    profile: (
        int
        | None
        | Literal[
            "dnxhd",
            "dnxhr_444",
            "dnxhr_hqx",
            "dnxhr_hq",
            "dnxhr_sq",
            "dnxhr_lb",
        ]
    ) = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`nitris_compat`	`bool \| None`	encode with Avid Nitris compatibility (default false)	`None`
`ibias`	`int \| None`	intra quant bias (from INT_MIN to INT_MAX) (default 0)	`None`
`profile`	`int \| None \| Literal['dnxhd', 'dnxhr_444', 'dnxhr_hqx', 'dnxhr_hq', 'dnxhr_sq', 'dnxhr_lb']`	(from 0 to 5) (default dnxhd)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

dpx ¶

dpx() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

dvbsub ¶

dvbsub() -> FFMpegEncoderOption

(codec dvb_subtitle)

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

dvdsub ¶

dvdsub(
    palette: str | None = None,
    even_rows_fix: bool | None = None,
) -> FFMpegEncoderOption

(codec dvd_subtitle)

Parameters:

Name	Type	Description	Default
`palette`	`str \| None`	set the global palette	`None`
`even_rows_fix`	`bool \| None`	Make number of rows even (workaround for some players) (default false)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

dvvideo ¶

dvvideo(
    quant_deadzone: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`quant_deadzone`	`int \| None`	Quantizer dead zone (from 0 to 1024) (default 7)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

eac3 ¶

eac3(
    mixing_level: int | None = None,
    room_type: (
        int
        | None
        | Literal["notindicated", "large", "small"]
    ) = None,
    per_frame_metadata: bool | None = None,
    copyright: int | None = None,
    dialnorm: int | None = None,
    dsur_mode: (
        int | None | Literal["notindicated", "on", "off"]
    ) = None,
    original: int | None = None,
    dmix_mode: (
        int
        | None
        | Literal["notindicated", "ltrt", "loro", "dplii"]
    ) = None,
    ltrt_cmixlev: float | None = None,
    ltrt_surmixlev: float | None = None,
    loro_cmixlev: float | None = None,
    loro_surmixlev: float | None = None,
    dsurex_mode: (
        int
        | None
        | Literal["notindicated", "on", "off", "dpliiz"]
    ) = None,
    dheadphone_mode: (
        int | None | Literal["notindicated", "on", "off"]
    ) = None,
    ad_conv_type: (
        int | None | Literal["standard", "hdcd"]
    ) = None,
    stereo_rematrixing: bool | None = None,
    channel_coupling: int | None | Literal["auto"] = None,
    cpl_start_band: int | None | Literal["auto"] = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`mixing_level`	`int \| None`	Mixing Level (from -1 to 111) (default -1)	`None`
`room_type`	`int \| None \| Literal['notindicated', 'large', 'small']`	Room Type (from -1 to 2) (default -1)	`None`
`per_frame_metadata`	`bool \| None`	Allow Changing Metadata Per-Frame (default false)	`None`
`copyright`	`int \| None`	Copyright Bit (from -1 to 1) (default -1)	`None`
`dialnorm`	`int \| None`	Dialogue Level (dB) (from -31 to -1) (default -31)	`None`
`dsur_mode`	`int \| None \| Literal['notindicated', 'on', 'off']`	Dolby Surround Mode (from -1 to 2) (default -1)	`None`
`original`	`int \| None`	Original Bit Stream (from -1 to 1) (default -1)	`None`
`dmix_mode`	`int \| None \| Literal['notindicated', 'ltrt', 'loro', 'dplii']`	Preferred Stereo Downmix Mode (from -1 to 3) (default -1)	`None`
`ltrt_cmixlev`	`float \| None`	Lt/Rt Center Mix Level (from -1 to 2) (default -1)	`None`
`ltrt_surmixlev`	`float \| None`	Lt/Rt Surround Mix Level (from -1 to 2) (default -1)	`None`
`loro_cmixlev`	`float \| None`	Lo/Ro Center Mix Level (from -1 to 2) (default -1)	`None`
`loro_surmixlev`	`float \| None`	Lo/Ro Surround Mix Level (from -1 to 2) (default -1)	`None`
`dsurex_mode`	`int \| None \| Literal['notindicated', 'on', 'off', 'dpliiz']`	Dolby Surround EX Mode (from -1 to 3) (default -1)	`None`
`dheadphone_mode`	`int \| None \| Literal['notindicated', 'on', 'off']`	Dolby Headphone Mode (from -1 to 2) (default -1)	`None`
`ad_conv_type`	`int \| None \| Literal['standard', 'hdcd']`	A/D Converter Type (from -1 to 1) (default -1)	`None`
`stereo_rematrixing`	`bool \| None`	Stereo Rematrixing (default true)	`None`
`channel_coupling`	`int \| None \| Literal['auto']`	Channel Coupling (from -1 to 1) (default auto)	`None`
`cpl_start_band`	`int \| None \| Literal['auto']`	Coupling Start Band (from -1 to 15) (default auto)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

exr ¶

exr(
    compression: (
        int | None | Literal["none", "rle", "zip1", "zip16"]
    ) = None,
    format: int | None | Literal["half", "float"] = None,
    gamma: float | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`compression`	`int \| None \| Literal['none', 'rle', 'zip1', 'zip16']`	set compression type (from 0 to 3) (default none)	`None`
`format`	`int \| None \| Literal['half', 'float']`	set pixel type (from 1 to 2) (default float)	`None`
`gamma`	`float \| None`	set gamma (from 0.001 to FLT_MAX) (default 1)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

ffv1 ¶

ffv1(
    slicecrc: bool | None = None,
    coder: (
        int
        | None
        | Literal["rice", "range_def", "range_tab", "ac"]
    ) = None,
    context: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`slicecrc`	`bool \| None`	Protect slices with CRCs (default auto)	`None`
`coder`	`int \| None \| Literal['rice', 'range_def', 'range_tab', 'ac']`	Coder type (from -2 to 2) (default rice)	`None`
`context`	`int \| None`	Context model (from 0 to 1) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

ffvhuff ¶

ffvhuff(
    non_deterministic: bool | None = None,
    pred: (
        int | None | Literal["left", "plane", "median"]
    ) = None,
    context: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`non_deterministic`	`bool \| None`	Allow multithreading for e.g. context=1 at the expense of determinism (default false)	`None`
`pred`	`int \| None \| Literal['left', 'plane', 'median']`	Prediction method (from 0 to 2) (default left)	`None`
`context`	`int \| None`	Set per-frame huffman tables (from 0 to 1) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

fits ¶

fits() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

flac ¶

flac(
    lpc_coeff_precision: int | None = None,
    lpc_type: (
        int
        | None
        | Literal["none", "fixed", "levinson", "cholesky"]
    ) = None,
    lpc_passes: int | None = None,
    min_partition_order: int | None = None,
    prediction_order_method: (
        int
        | None
        | Literal[
            "estimation",
            "2level",
            "4level",
            "8level",
            "search",
            "log",
        ]
    ) = None,
    ch_mode: (
        int
        | None
        | Literal[
            "auto",
            "indep",
            "left_side",
            "right_side",
            "mid_side",
        ]
    ) = None,
    exact_rice_parameters: bool | None = None,
    multi_dim_quant: bool | None = None,
    min_prediction_order: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`lpc_coeff_precision`	`int \| None`	LPC coefficient precision (from 0 to 15) (default 15)	`None`
`lpc_type`	`int \| None \| Literal['none', 'fixed', 'levinson', 'cholesky']`	LPC algorithm (from -1 to 3) (default -1)	`None`
`lpc_passes`	`int \| None`	Number of passes to use for Cholesky factorization during LPC analysis (from 1 to INT_MAX) (default 2)	`None`
`min_partition_order`	`int \| None`	(from -1 to 8) (default -1)	`None`
`prediction_order_method`	`int \| None \| Literal['estimation', '2level', '4level', '8level', 'search', 'log']`	Search method for selecting prediction order (from -1 to 5) (default -1)	`None`
`ch_mode`	`int \| None \| Literal['auto', 'indep', 'left_side', 'right_side', 'mid_side']`	Stereo decorrelation mode (from -1 to 3) (default auto)	`None`
`exact_rice_parameters`	`bool \| None`	Calculate rice parameters exactly (default false)	`None`
`multi_dim_quant`	`bool \| None`	Multi-dimensional quantization (default false)	`None`
`min_prediction_order`	`int \| None`	(from -1 to 32) (default -1)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

flashsv ¶

flashsv() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

flashsv2 ¶

flashsv2() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

flv ¶

flv(
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

(codec flv1)

Parameters:

Name	Type	Description	Default
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

g722 ¶

g722() -> FFMpegEncoderOption

(codec adpcm_g722)

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

g723_1 ¶

g723_1() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

g726 ¶

g726(code_size: int | None = None) -> FFMpegEncoderOption

(codec adpcm_g726)

Parameters:

Name	Type	Description	Default
`code_size`	`int \| None`	Bits per code (from 2 to 5) (default 4)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

g726le ¶

g726le(code_size: int | None = None) -> FFMpegEncoderOption

(codec adpcm_g726le)

Parameters:

Name	Type	Description	Default
`code_size`	`int \| None`	Bits per code (from 2 to 5) (default 4)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

gif ¶

gif(
    gifflags: str | None = None,
    gifimage: bool | None = None,
    global_palette: bool | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`gifflags`	`str \| None`	set GIF flags (default offsetting+transdiff)	`None`
`gifimage`	`bool \| None`	enable encoding only images per frame (default false)	`None`
`global_palette`	`bool \| None`	write a palette to the global gif header where feasible (default true)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

h261 ¶

h261(
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

h263 ¶

h263(
    obmc: bool | None = None,
    mb_info: int | None = None,
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`obmc`	`bool \| None`	use overlapped block motion compensation. (default false)	`None`
`mb_info`	`int \| None`	emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size (from 0 to INT_MAX) (default 0)	`None`
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

h263_v4l2m2m ¶

h263_v4l2m2m(
    num_output_buffers: int | None = None,
    num_capture_buffers: int | None = None,
) -> FFMpegEncoderOption

(codec h263)

Parameters:

Name	Type	Description	Default
`num_output_buffers`	`int \| None`	Number of buffers in the output context (from 2 to INT_MAX) (default 16)	`None`
`num_capture_buffers`	`int \| None`	Number of buffers in the capture context (from 4 to INT_MAX) (default 4)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

h263p ¶

h263p(
    umv: bool | None = None,
    aiv: bool | None = None,
    obmc: bool | None = None,
    structured_slices: bool | None = None,
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`umv`	`bool \| None`	Use unlimited motion vectors. (default false)	`None`
`aiv`	`bool \| None`	Use alternative inter VLC. (default false)	`None`
`obmc`	`bool \| None`	use overlapped block motion compensation. (default false)	`None`
`structured_slices`	`bool \| None`	Write slice start position at every GOB header instead of just GOB number. (default false)	`None`
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

h264_v4l2m2m ¶

h264_v4l2m2m(
    num_output_buffers: int | None = None,
    num_capture_buffers: int | None = None,
) -> FFMpegEncoderOption

(codec h264)

Parameters:

Name	Type	Description	Default
`num_output_buffers`	`int \| None`	Number of buffers in the output context (from 2 to INT_MAX) (default 16)	`None`
`num_capture_buffers`	`int \| None`	Number of buffers in the capture context (from 4 to INT_MAX) (default 4)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

h264_vaapi ¶

h264_vaapi(
    low_power: bool | None = None,
    idr_interval: int | None = None,
    b_depth: int | None = None,
    async_depth: int | None = None,
    max_frame_size: int | None = None,
    rc_mode: (
        int
        | None
        | Literal[
            "auto",
            "CQP",
            "CBR",
            "VBR",
            "ICQ",
            "QVBR",
            "AVBR",
        ]
    ) = None,
    qp: int | None = None,
    quality: int | None = None,
    coder: (
        int | None | Literal["cavlc", "cabac", "vlc", "ac"]
    ) = None,
    aud: bool | None = None,
    sei: str | None = None,
    profile: (
        int
        | None
        | Literal[
            "constrained_baseline", "main", "high", "high10"
        ]
    ) = None,
    level: (
        int
        | None
        | Literal[
            "1",
            "1.1",
            "1.2",
            "1.3",
            "2",
            "2.1",
            "2.2",
            "3",
            "3.1",
            "3.2",
            "4",
            "4.1",
            "4.2",
            "5",
            "5.1",
            "5.2",
            "6",
            "6.1",
            "6.2",
        ]
    ) = None,
) -> FFMpegEncoderOption

(codec h264)

Parameters:

Name	Type	Description	Default
`low_power`	`bool \| None`	Use low-power encoding mode (only available on some platforms; may not support all encoding features) (default false)	`None`
`idr_interval`	`int \| None`	Distance (in I-frames) between IDR frames (from 0 to INT_MAX) (default 0)	`None`
`b_depth`	`int \| None`	Maximum B-frame reference depth (from 1 to INT_MAX) (default 1)	`None`
`async_depth`	`int \| None`	Maximum processing parallelism. Increase this to improve single channel performance. This option doesn't work if driver doesn't implement vaSyncBuffer function. (from 1 to 64) (default 2)	`None`
`max_frame_size`	`int \| None`	Maximum frame size (in bytes) (from 0 to INT_MAX) (default 0)	`None`
`rc_mode`	`int \| None \| Literal['auto', 'CQP', 'CBR', 'VBR', 'ICQ', 'QVBR', 'AVBR']`	Set rate control mode (from 0 to 6) (default auto)	`None`
`qp`	`int \| None`	Constant QP (for P-frames; scaled by qfactor/qoffset for I/B) (from 0 to 52) (default 0)	`None`
`quality`	`int \| None`	Set encode quality (trades off against speed, higher is faster) (from -1 to INT_MAX) (default -1)	`None`
`coder`	`int \| None \| Literal['cavlc', 'cabac', 'vlc', 'ac']`	Entropy coder type (from 0 to 1) (default cabac)	`None`
`aud`	`bool \| None`	Include AUD (default false)	`None`
`sei`	`str \| None`	Set SEI to include (default identifier+timing+recovery_point+a53_cc)	`None`
`profile`	`int \| None \| Literal['constrained_baseline', 'main', 'high', 'high10']`	Set profile (profile_idc and constraint_set*_flag) (from -99 to 65535) (default -99)	`None`
`level`	`int \| None \| Literal['1', '1.1', '1.2', '1.3', '2', '2.1', '2.2', '3', '3.1', '3.2', '4', '4.1', '4.2', '5', '5.1', '5.2', '6', '6.1', '6.2']`	Set level (level_idc) (from -99 to 255) (default -99)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

hdr ¶

hdr() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

hevc_v4l2m2m ¶

hevc_v4l2m2m(
    num_output_buffers: int | None = None,
    num_capture_buffers: int | None = None,
) -> FFMpegEncoderOption

(codec hevc)

Parameters:

Name	Type	Description	Default
`num_output_buffers`	`int \| None`	Number of buffers in the output context (from 2 to INT_MAX) (default 16)	`None`
`num_capture_buffers`	`int \| None`	Number of buffers in the capture context (from 4 to INT_MAX) (default 4)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

hevc_vaapi ¶

hevc_vaapi(
    low_power: bool | None = None,
    idr_interval: int | None = None,
    b_depth: int | None = None,
    async_depth: int | None = None,
    max_frame_size: int | None = None,
    rc_mode: (
        int
        | None
        | Literal[
            "auto",
            "CQP",
            "CBR",
            "VBR",
            "ICQ",
            "QVBR",
            "AVBR",
        ]
    ) = None,
    qp: int | None = None,
    aud: bool | None = None,
    profile: (
        int | None | Literal["main", "main10", "rext"]
    ) = None,
    tier: int | None | Literal["main", "high"] = None,
    level: (
        int
        | None
        | Literal[
            "1",
            "2",
            "2.1",
            "3",
            "3.1",
            "4",
            "4.1",
            "5",
            "5.1",
            "5.2",
            "6",
            "6.1",
            "6.2",
        ]
    ) = None,
    sei: str | None = None,
    tiles: str | None = None,
) -> FFMpegEncoderOption

(codec hevc)

Parameters:

Name	Type	Description	Default
`low_power`	`bool \| None`	Use low-power encoding mode (only available on some platforms; may not support all encoding features) (default false)	`None`
`idr_interval`	`int \| None`	Distance (in I-frames) between IDR frames (from 0 to INT_MAX) (default 0)	`None`
`b_depth`	`int \| None`	Maximum B-frame reference depth (from 1 to INT_MAX) (default 1)	`None`
`async_depth`	`int \| None`	Maximum processing parallelism. Increase this to improve single channel performance. This option doesn't work if driver doesn't implement vaSyncBuffer function. (from 1 to 64) (default 2)	`None`
`max_frame_size`	`int \| None`	Maximum frame size (in bytes) (from 0 to INT_MAX) (default 0)	`None`
`rc_mode`	`int \| None \| Literal['auto', 'CQP', 'CBR', 'VBR', 'ICQ', 'QVBR', 'AVBR']`	Set rate control mode (from 0 to 6) (default auto)	`None`
`qp`	`int \| None`	Constant QP (for P-frames; scaled by qfactor/qoffset for I/B) (from 0 to 52) (default 0)	`None`
`aud`	`bool \| None`	Include AUD (default false)	`None`
`profile`	`int \| None \| Literal['main', 'main10', 'rext']`	Set profile (general_profile_idc) (from -99 to 255) (default -99)	`None`
`tier`	`int \| None \| Literal['main', 'high']`	Set tier (general_tier_flag) (from 0 to 1) (default main)	`None`
`level`	`int \| None \| Literal['1', '2', '2.1', '3', '3.1', '4', '4.1', '5', '5.1', '5.2', '6', '6.1', '6.2']`	Set level (general_level_idc) (from -99 to 255) (default -99)	`None`
`sei`	`str \| None`	Set SEI to include (default hdr+a53_cc)	`None`
`tiles`	`str \| None`	Tile columns x rows	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

huffyuv ¶

huffyuv(
    non_deterministic: bool | None = None,
    pred: (
        int | None | Literal["left", "plane", "median"]
    ) = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`non_deterministic`	`bool \| None`	Allow multithreading for e.g. context=1 at the expense of determinism (default false)	`None`
`pred`	`int \| None \| Literal['left', 'plane', 'median']`	Prediction method (from 0 to 2) (default left)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

jpeg2000 ¶

jpeg2000(
    format: int | None | Literal["j2k", "jp2"] = None,
    tile_width: int | None = None,
    tile_height: int | None = None,
    pred: int | None | Literal["dwt97int", "dwt53"] = None,
    sop: int | None = None,
    eph: int | None = None,
    prog: (
        int
        | None
        | Literal["lrcp", "rlcp", "rpcl", "pcrl", "cprl"]
    ) = None,
    layer_rates: str | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`format`	`int \| None \| Literal['j2k', 'jp2']`	Codec Format (from 0 to 1) (default jp2)	`None`
`tile_width`	`int \| None`	Tile Width (from 1 to 1.07374e+09) (default 256)	`None`
`tile_height`	`int \| None`	Tile Height (from 1 to 1.07374e+09) (default 256)	`None`
`pred`	`int \| None \| Literal['dwt97int', 'dwt53']`	DWT Type (from 0 to 1) (default dwt97int)	`None`
`sop`	`int \| None`	SOP marker (from 0 to 1) (default 0)	`None`
`eph`	`int \| None`	EPH marker (from 0 to 1) (default 0)	`None`
`prog`	`int \| None \| Literal['lrcp', 'rlcp', 'rpcl', 'pcrl', 'cprl']`	Progression Order (from 0 to 4) (default lrcp)	`None`
`layer_rates`	`str \| None`	Layer Rates	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

jpegls ¶

jpegls(
    pred: (
        int | None | Literal["left", "plane", "median"]
    ) = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`pred`	`int \| None \| Literal['left', 'plane', 'median']`	Prediction method (from 0 to 2) (default left)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libfdk_aac ¶

libfdk_aac(
    afterburner: int | None = None,
    eld_sbr: int | None = None,
    eld_v2: int | None = None,
    signaling: (
        int
        | None
        | Literal[
            "default",
            "implicit",
            "explicit_sbr",
            "explicit_hierarchical",
        ]
    ) = None,
    latm: int | None = None,
    header_period: int | None = None,
    vbr: int | None = None,
    drc_profile: int | None = None,
    drc_target_ref: int | None = None,
    comp_profile: int | None = None,
    comp_target_ref: int | None = None,
    prog_ref: int | None = None,
    frame_length: int | None = None,
) -> FFMpegEncoderOption

(codec aac)

Parameters:

Name	Type	Description	Default
`afterburner`	`int \| None`	Afterburner (improved quality) (from 0 to 1) (default 1)	`None`
`eld_sbr`	`int \| None`	Enable SBR for ELD (for SBR in other configurations, use the -profile parameter) (from 0 to 1) (default 0)	`None`
`eld_v2`	`int \| None`	Enable ELDv2 (LD-MPS extension for ELD stereo signals) (from 0 to 1) (default 0)	`None`
`signaling`	`int \| None \| Literal['default', 'implicit', 'explicit_sbr', 'explicit_hierarchical']`	SBR/PS signaling style (from -1 to 2) (default default)	`None`
`latm`	`int \| None`	Output LATM/LOAS encapsulated data (from 0 to 1) (default 0)	`None`
`header_period`	`int \| None`	StreamMuxConfig and PCE repetition period (in frames) (from 0 to 65535) (default 0)	`None`
`vbr`	`int \| None`	VBR mode (1-5) (from 0 to 5) (default 0)	`None`
`drc_profile`	`int \| None`	The desired compression profile for AAC DRC (from 0 to 256) (default 0)	`None`
`drc_target_ref`	`int \| None`	Expected target reference level at decoder side in dB (for clipping prevention/limiter) (from -31.75 to 0) (default 0)	`None`
`comp_profile`	`int \| None`	The desired compression profile for AAC DRC (from 0 to 256) (default 0)	`None`
`comp_target_ref`	`int \| None`	Expected target reference level at decoder side in dB (for clipping prevention/limiter) (from -31.75 to 0) (default 0)	`None`
`prog_ref`	`int \| None`	The program reference level or dialog level in dB (from -31.75 to 0) (default 0)	`None`
`frame_length`	`int \| None`	The desired frame length (from -1 to 1024) (default -1)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libkvazaar ¶

libkvazaar(
    kvazaar_params: str | None = None,
) -> FFMpegEncoderOption

(codec hevc)

Parameters:

Name	Type	Description	Default
`kvazaar_params`	`str \| None`	Set kvazaar parameters as a comma-separated list of key=value pairs.	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libmp3lame ¶

libmp3lame(
    reservoir: bool | None = None,
    joint_stereo: bool | None = None,
    abr: bool | None = None,
    copyright: bool | None = None,
    original: bool | None = None,
) -> FFMpegEncoderOption

(codec mp3)

Parameters:

Name	Type	Description	Default
`reservoir`	`bool \| None`	use bit reservoir (default true)	`None`
`joint_stereo`	`bool \| None`	use joint stereo (default true)	`None`
`abr`	`bool \| None`	use ABR (default false)	`None`
`copyright`	`bool \| None`	set copyright flag (default false)	`None`
`original`	`bool \| None`	set original flag (default true)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libopencore_amrnb ¶

libopencore_amrnb(
    dtx: int | None = None,
) -> FFMpegEncoderOption

(codec amr_nb)

Parameters:

Name	Type	Description	Default
`dtx`	`int \| None`	Allow DTX (generate comfort noise) (from 0 to 1) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libopenjpeg ¶

libopenjpeg(
    format: int | None | Literal["j2k", "jp2"] = None,
    profile: (
        int
        | None
        | Literal["jpeg2000", "cinema2k", "cinema4k"]
    ) = None,
    cinema_mode: (
        int
        | None
        | Literal["off", "2k_24", "2k_48", "4k_24"]
    ) = None,
    prog_order: (
        int
        | None
        | Literal["lrcp", "rlcp", "rpcl", "pcrl", "cprl"]
    ) = None,
    numresolution: int | None = None,
    irreversible: int | None = None,
    disto_alloc: int | None = None,
    fixed_quality: int | None = None,
) -> FFMpegEncoderOption

(codec jpeg2000)

Parameters:

Name	Type	Description	Default
`format`	`int \| None \| Literal['j2k', 'jp2']`	Codec Format (from 0 to 2) (default jp2)	`None`
`profile`	`int \| None \| Literal['jpeg2000', 'cinema2k', 'cinema4k']`	(from 0 to 4) (default jpeg2000)	`None`
`cinema_mode`	`int \| None \| Literal['off', '2k_24', '2k_48', '4k_24']`	Digital Cinema (from 0 to 3) (default off)	`None`
`prog_order`	`int \| None \| Literal['lrcp', 'rlcp', 'rpcl', 'pcrl', 'cprl']`	Progression Order (from 0 to 4) (default lrcp)	`None`
`numresolution`	`int \| None`	(from 0 to 33) (default 6)	`None`
`irreversible`	`int \| None`	(from 0 to 1) (default 0)	`None`
`disto_alloc`	`int \| None`	(from 0 to 1) (default 1)	`None`
`fixed_quality`	`int \| None`	(from 0 to 1) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libopus ¶

libopus(
    application: (
        int | None | Literal["voip", "audio", "lowdelay"]
    ) = None,
    frame_duration: float | None = None,
    packet_loss: int | None = None,
    fec: bool | None = None,
    vbr: (
        int | None | Literal["off", "on", "constrained"]
    ) = None,
    mapping_family: int | None = None,
    apply_phase_inv: bool | None = None,
) -> FFMpegEncoderOption

(codec opus)

Parameters:

Name	Type	Description	Default
`application`	`int \| None \| Literal['voip', 'audio', 'lowdelay']`	Intended application type (from 2048 to 2051) (default audio)	`None`
`frame_duration`	`float \| None`	Duration of a frame in milliseconds (from 2.5 to 120) (default 20)	`None`
`packet_loss`	`int \| None`	Expected packet loss percentage (from 0 to 100) (default 0)	`None`
`fec`	`bool \| None`	Enable inband FEC. Expected packet loss must be non-zero (default false)	`None`
`vbr`	`int \| None \| Literal['off', 'on', 'constrained']`	Variable bit rate mode (from 0 to 2) (default on)	`None`
`mapping_family`	`int \| None`	Channel Mapping Family (from -1 to 255) (default -1)	`None`
`apply_phase_inv`	`bool \| None`	Apply intensity stereo phase inversion (default true)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libsvtav1 ¶

libsvtav1(
    hielevel: (
        int | None | Literal["3level", "4level"]
    ) = None,
    la_depth: int | None = None,
    tier: int | None | Literal["main", "high"] = None,
    preset: int | None = None,
    crf: int | None = None,
    qp: int | None = None,
    sc_detection: bool | None = None,
    tile_columns: int | None = None,
    tile_rows: int | None = None,
    svtav1_params: str | None = None,
) -> FFMpegEncoderOption

(codec av1)

Parameters:

Name	Type	Description	Default
`hielevel`	`int \| None \| Literal['3level', '4level']`	Hierarchical prediction levels setting (Deprecated, use svtav1-params) (from -1 to 4) (default -1)	`None`
`la_depth`	`int \| None`	Look ahead distance [0, 120] (Deprecated, use svtav1-params) (from -1 to 120) (default -1)	`None`
`tier`	`int \| None \| Literal['main', 'high']`	Set operating point tier (Deprecated, use svtav1-params) (from -1 to 1) (default -1)	`None`
`preset`	`int \| None`	Encoding preset (from -2 to 13) (default -2)	`None`
`crf`	`int \| None`	Constant Rate Factor value (from 0 to 63) (default 0)	`None`
`qp`	`int \| None`	Initial Quantizer level value (from 0 to 63) (default 0)	`None`
`sc_detection`	`bool \| None`	Scene change detection (Deprecated, use svtav1-params) (default auto)	`None`
`tile_columns`	`int \| None`	Log2 of number of tile columns to use (Deprecated, use svtav1-params) (from -1 to 4) (default -1)	`None`
`tile_rows`	`int \| None`	Log2 of number of tile rows to use (Deprecated, use svtav1-params) (from -1 to 6) (default -1)	`None`
`svtav1_params`	`str \| None`	Set the SVT-AV1 configuration using a :-separated list of key=value parameters	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libtheora ¶

libtheora() -> FFMpegEncoderOption

(codec theora)

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libvorbis ¶

libvorbis(
    iblock: float | None = None,
) -> FFMpegEncoderOption

(codec vorbis)

Parameters:

Name	Type	Description	Default
`iblock`	`float \| None`	Sets the impulse block bias (from -15 to 0) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libvpx ¶

libvpx(
    lag_in_frames: int | None = None,
    arnr_maxframes: int | None = None,
    arnr_strength: int | None = None,
    arnr_type: (
        int
        | None
        | Literal["backward", "forward", "centered"]
    ) = None,
    tune: int | None | Literal["psnr", "ssim"] = None,
    deadline: (
        int | None | Literal["best", "good", "realtime"]
    ) = None,
    error_resilient: str | None = None,
    max_intra_rate: int | None = None,
    crf: int | None = None,
    static_thresh: int | None = None,
    drop_threshold: int | None = None,
    noise_sensitivity: int | None = None,
    undershoot_pct: int | None = None,
    overshoot_pct: int | None = None,
    ts_parameters: str | None = None,
    auto_alt_ref: int | None = None,
    cpu_used: int | None = None,
    speed: int | None = None,
    quality: (
        int | None | Literal["best", "good", "realtime"]
    ) = None,
    vp8flags: str | None = None,
    arnr_max_frames: int | None = None,
    rc_lookahead: int | None = None,
    sharpness: int | None = None,
) -> FFMpegEncoderOption

(codec vp8)

Parameters:

Name	Type	Description	Default
`lag_in_frames`	`int \| None`	Number of frames to look ahead for alternate reference frame selection (from -1 to INT_MAX) (default -1)	`None`
`arnr_maxframes`	`int \| None`	altref noise reduction max frame count (from -1 to INT_MAX) (default -1)	`None`
`arnr_strength`	`int \| None`	altref noise reduction filter strength (from -1 to INT_MAX) (default -1)	`None`
`arnr_type`	`int \| None \| Literal['backward', 'forward', 'centered']`	altref noise reduction filter type (from -1 to INT_MAX) (default -1)	`None`
`tune`	`int \| None \| Literal['psnr', 'ssim']`	Tune the encoding to a specific scenario (from -1 to INT_MAX) (default -1)	`None`
`deadline`	`int \| None \| Literal['best', 'good', 'realtime']`	Time to spend encoding, in microseconds. (from INT_MIN to INT_MAX) (default good)	`None`
`error_resilient`	`str \| None`	Error resilience configuration (default 0)	`None`
`max_intra_rate`	`int \| None`	Maximum I-frame bitrate (pct) 0=unlimited (from -1 to INT_MAX) (default -1)	`None`
`crf`	`int \| None`	Select the quality for constant quality mode (from -1 to 63) (default -1)	`None`
`static_thresh`	`int \| None`	A change threshold on blocks below which they will be skipped by the encoder (from 0 to INT_MAX) (default 0)	`None`
`drop_threshold`	`int \| None`	Frame drop threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_sensitivity`	`int \| None`	Noise sensitivity (from 0 to 4) (default 0)	`None`
`undershoot_pct`	`int \| None`	Datarate undershoot (min) target (%) (from -1 to 100) (default -1)	`None`
`overshoot_pct`	`int \| None`	Datarate overshoot (max) target (%) (from -1 to 1000) (default -1)	`None`
`ts_parameters`	`str \| None`	Temporal scaling configuration using a :-separated list of key=value parameters	`None`
`auto_alt_ref`	`int \| None`	Enable use of alternate reference frames (2-pass only) (from -1 to 2) (default -1)	`None`
`cpu_used`	`int \| None`	Quality/Speed ratio modifier (from -16 to 16) (default 1)	`None`
`speed`	`int \| None`	(from -16 to 16) (default 1)	`None`
`quality`	`int \| None \| Literal['best', 'good', 'realtime']`	(from INT_MIN to INT_MAX) (default good)	`None`
`vp8flags`	`str \| None`	(default 0)	`None`
`arnr_max_frames`	`int \| None`	altref noise reduction max frame count (from 0 to 15) (default 0)	`None`
`rc_lookahead`	`int \| None`	Number of frames to look ahead for alternate reference frame selection (from 0 to 25) (default 25)	`None`
`sharpness`	`int \| None`	Increase sharpness at the expense of lower PSNR (from -1 to 7) (default -1)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libwebp ¶

libwebp(
    lossless: int | None = None,
    preset: (
        int
        | None
        | Literal[
            "none",
            "default",
            "picture",
            "photo",
            "drawing",
            "icon",
            "text",
        ]
    ) = None,
    cr_threshold: int | None = None,
    cr_size: int | None = None,
    quality: float | None = None,
) -> FFMpegEncoderOption

(codec webp)

Parameters:

Name	Type	Description	Default
`lossless`	`int \| None`	Use lossless mode (from 0 to 1) (default 0)	`None`
`preset`	`int \| None \| Literal['none', 'default', 'picture', 'photo', 'drawing', 'icon', 'text']`	Configuration preset (from -1 to 5) (default none)	`None`
`cr_threshold`	`int \| None`	Conditional replenishment threshold (from 0 to INT_MAX) (default 0)	`None`
`cr_size`	`int \| None`	Conditional replenishment block size (from 0 to 256) (default 16)	`None`
`quality`	`float \| None`	Quality (from 0 to 100) (default 75)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libwebp_anim ¶

libwebp_anim(
    lossless: int | None = None,
    preset: (
        int
        | None
        | Literal[
            "none",
            "default",
            "picture",
            "photo",
            "drawing",
            "icon",
            "text",
        ]
    ) = None,
    cr_threshold: int | None = None,
    cr_size: int | None = None,
    quality: float | None = None,
) -> FFMpegEncoderOption

(codec webp)

Parameters:

Name	Type	Description	Default
`lossless`	`int \| None`	Use lossless mode (from 0 to 1) (default 0)	`None`
`preset`	`int \| None \| Literal['none', 'default', 'picture', 'photo', 'drawing', 'icon', 'text']`	Configuration preset (from -1 to 5) (default none)	`None`
`cr_threshold`	`int \| None`	Conditional replenishment threshold (from 0 to INT_MAX) (default 0)	`None`
`cr_size`	`int \| None`	Conditional replenishment block size (from 0 to 256) (default 16)	`None`
`quality`	`float \| None`	Quality (from 0 to 100) (default 75)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libx264 ¶

libx264(
    preset: str | None = None,
    tune: str | None = None,
    profile: str | None = None,
    fastfirstpass: bool | None = None,
    level: str | None = None,
    passlogfile: str | None = None,
    wpredp: str | None = None,
    a53cc: bool | None = None,
    x264opts: str | None = None,
    crf: float | None = None,
    crf_max: float | None = None,
    qp: int | None = None,
    aq_mode: (
        int
        | None
        | Literal[
            "none",
            "variance",
            "autovariance",
            "autovariance-biased",
        ]
    ) = None,
    aq_strength: float | None = None,
    psy: bool | None = None,
    psy_rd: str | None = None,
    rc_lookahead: int | None = None,
    weightb: bool | None = None,
    weightp: (
        int | None | Literal["none", "simple", "smart"]
    ) = None,
    ssim: bool | None = None,
    intra_refresh: bool | None = None,
    bluray_compat: bool | None = None,
    b_bias: int | None = None,
    b_pyramid: (
        int | None | Literal["none", "strict", "normal"]
    ) = None,
    mixed_refs: bool | None = None,
    _8x8dct: bool | None = None,
    fast_pskip: bool | None = None,
    aud: bool | None = None,
    mbtree: bool | None = None,
    deblock: str | None = None,
    cplxblur: float | None = None,
    partitions: str | None = None,
    direct_pred: (
        int
        | None
        | Literal["none", "spatial", "temporal", "auto"]
    ) = None,
    slice_max_size: int | None = None,
    stats: str | None = None,
    nal_hrd: (
        int | None | Literal["none", "vbr", "cbr"]
    ) = None,
    avcintra_class: int | None = None,
    me_method: (
        int
        | None
        | Literal["dia", "hex", "umh", "esa", "tesa"]
    ) = None,
    forced_idr: bool | None = None,
    coder: (
        int
        | None
        | Literal["default", "cavlc", "cabac", "vlc", "ac"]
    ) = None,
    b_strategy: int | None = None,
    chromaoffset: int | None = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    udu_sei: bool | None = None,
    x264_params: str | None = None,
    mb_info: bool | None = None,
) -> FFMpegEncoderOption

(codec h264)

Parameters:

Name	Type	Description	Default
`preset`	`str \| None`	Set the encoding preset (cf. x264 --fullhelp) (default "medium")	`None`
`tune`	`str \| None`	Tune the encoding params (cf. x264 --fullhelp)	`None`
`profile`	`str \| None`	Set profile restrictions (cf. x264 --fullhelp)	`None`
`fastfirstpass`	`bool \| None`	Use fast settings when encoding first pass (default true)	`None`
`level`	`str \| None`	Specify level (as defined by Annex A)	`None`
`passlogfile`	`str \| None`	Filename for 2 pass stats	`None`
`wpredp`	`str \| None`	Weighted prediction for P-frames	`None`
`a53cc`	`bool \| None`	Use A53 Closed Captions (if available) (default true)	`None`
`x264opts`	`str \| None`	x264 options	`None`
`crf`	`float \| None`	Select the quality for constant quality mode (from -1 to FLT_MAX) (default -1)	`None`
`crf_max`	`float \| None`	In CRF mode, prevents VBV from lowering quality beyond this point. (from -1 to FLT_MAX) (default -1)	`None`
`qp`	`int \| None`	Constant quantization parameter rate control method (from -1 to INT_MAX) (default -1)	`None`
`aq_mode`	`int \| None \| Literal['none', 'variance', 'autovariance', 'autovariance-biased']`	AQ method (from -1 to INT_MAX) (default -1)	`None`
`aq_strength`	`float \| None`	AQ strength. Reduces blocking and blurring in flat and textured areas. (from -1 to FLT_MAX) (default -1)	`None`
`psy`	`bool \| None`	Use psychovisual optimizations. (default auto)	`None`
`psy_rd`	`str \| None`	Strength of psychovisual optimization, in : format.	`None`
`rc_lookahead`	`int \| None`	Number of frames to look ahead for frametype and ratecontrol (from -1 to INT_MAX) (default -1)	`None`
`weightb`	`bool \| None`	Weighted prediction for B-frames. (default auto)	`None`
`weightp`	`int \| None \| Literal['none', 'simple', 'smart']`	Weighted prediction analysis method. (from -1 to INT_MAX) (default -1)	`None`
`ssim`	`bool \| None`	Calculate and print SSIM stats. (default auto)	`None`
`intra_refresh`	`bool \| None`	Use Periodic Intra Refresh instead of IDR frames. (default auto)	`None`
`bluray_compat`	`bool \| None`	Bluray compatibility workarounds. (default auto)	`None`
`b_bias`	`int \| None`	Influences how often B-frames are used (from INT_MIN to INT_MAX) (default INT_MIN)	`None`
`b_pyramid`	`int \| None \| Literal['none', 'strict', 'normal']`	Keep some B-frames as references. (from -1 to INT_MAX) (default -1)	`None`
`mixed_refs`	`bool \| None`	One reference per partition, as opposed to one reference per macroblock (default auto)	`None`
`_8x8dct`	`bool \| None`	High profile 8x8 transform. (default auto)	`None`
`fast_pskip`	`bool \| None`	(default auto)	`None`
`aud`	`bool \| None`	Use access unit delimiters. (default auto)	`None`
`mbtree`	`bool \| None`	Use macroblock tree ratecontrol. (default auto)	`None`
`deblock`	`str \| None`	Loop filter parameters, in form.	`None`
`cplxblur`	`float \| None`	Reduce fluctuations in QP (before curve compression) (from -1 to FLT_MAX) (default -1)	`None`
`partitions`	`str \| None`	A comma-separated list of partitions to consider. Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all	`None`
`direct_pred`	`int \| None \| Literal['none', 'spatial', 'temporal', 'auto']`	Direct MV prediction mode (from -1 to INT_MAX) (default -1)	`None`
`slice_max_size`	`int \| None`	Limit the size of each slice in bytes (from -1 to INT_MAX) (default -1)	`None`
`stats`	`str \| None`	Filename for 2 pass stats	`None`
`nal_hrd`	`int \| None \| Literal['none', 'vbr', 'cbr']`	Signal HRD information (requires vbv-bufsize; cbr not allowed in .mp4) (from -1 to INT_MAX) (default -1)	`None`
`avcintra_class`	`int \| None`	AVC-Intra class 50/100/200/300/480 (from -1 to 480) (default -1)	`None`
`me_method`	`int \| None \| Literal['dia', 'hex', 'umh', 'esa', 'tesa']`	Set motion estimation method (from -1 to 4) (default -1)	`None`
`forced_idr`	`bool \| None`	If forcing keyframes, force them as IDR frames. (default false)	`None`
`coder`	`int \| None \| Literal['default', 'cavlc', 'cabac', 'vlc', 'ac']`	Coder type (from -1 to 1) (default default)	`None`
`b_strategy`	`int \| None`	Strategy to choose between I/P/B-frames (from -1 to 2) (default -1)	`None`
`chromaoffset`	`int \| None`	QP difference between chroma and luma (from INT_MIN to INT_MAX) (default 0)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default -1)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default -1)	`None`
`udu_sei`	`bool \| None`	Use user data unregistered SEI if available (default false)	`None`
`x264_params`	`str \| None`	Override the x264 configuration using a :-separated list of key=value parameters	`None`
`mb_info`	`bool \| None`	Set mb_info data through AVSideData, only useful when used from the API (default false)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libx264rgb ¶

libx264rgb(
    preset: str | None = None,
    tune: str | None = None,
    profile: str | None = None,
    fastfirstpass: bool | None = None,
    level: str | None = None,
    passlogfile: str | None = None,
    wpredp: str | None = None,
    a53cc: bool | None = None,
    x264opts: str | None = None,
    crf: float | None = None,
    crf_max: float | None = None,
    qp: int | None = None,
    aq_mode: (
        int
        | None
        | Literal[
            "none",
            "variance",
            "autovariance",
            "autovariance-biased",
        ]
    ) = None,
    aq_strength: float | None = None,
    psy: bool | None = None,
    psy_rd: str | None = None,
    rc_lookahead: int | None = None,
    weightb: bool | None = None,
    weightp: (
        int | None | Literal["none", "simple", "smart"]
    ) = None,
    ssim: bool | None = None,
    intra_refresh: bool | None = None,
    bluray_compat: bool | None = None,
    b_bias: int | None = None,
    b_pyramid: (
        int | None | Literal["none", "strict", "normal"]
    ) = None,
    mixed_refs: bool | None = None,
    _8x8dct: bool | None = None,
    fast_pskip: bool | None = None,
    aud: bool | None = None,
    mbtree: bool | None = None,
    deblock: str | None = None,
    cplxblur: float | None = None,
    partitions: str | None = None,
    direct_pred: (
        int
        | None
        | Literal["none", "spatial", "temporal", "auto"]
    ) = None,
    slice_max_size: int | None = None,
    stats: str | None = None,
    nal_hrd: (
        int | None | Literal["none", "vbr", "cbr"]
    ) = None,
    avcintra_class: int | None = None,
    me_method: (
        int
        | None
        | Literal["dia", "hex", "umh", "esa", "tesa"]
    ) = None,
    forced_idr: bool | None = None,
    coder: (
        int
        | None
        | Literal["default", "cavlc", "cabac", "vlc", "ac"]
    ) = None,
    b_strategy: int | None = None,
    chromaoffset: int | None = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    udu_sei: bool | None = None,
    x264_params: str | None = None,
    mb_info: bool | None = None,
) -> FFMpegEncoderOption

(codec h264)

Parameters:

Name	Type	Description	Default
`preset`	`str \| None`	Set the encoding preset (cf. x264 --fullhelp) (default "medium")	`None`
`tune`	`str \| None`	Tune the encoding params (cf. x264 --fullhelp)	`None`
`profile`	`str \| None`	Set profile restrictions (cf. x264 --fullhelp)	`None`
`fastfirstpass`	`bool \| None`	Use fast settings when encoding first pass (default true)	`None`
`level`	`str \| None`	Specify level (as defined by Annex A)	`None`
`passlogfile`	`str \| None`	Filename for 2 pass stats	`None`
`wpredp`	`str \| None`	Weighted prediction for P-frames	`None`
`a53cc`	`bool \| None`	Use A53 Closed Captions (if available) (default true)	`None`
`x264opts`	`str \| None`	x264 options	`None`
`crf`	`float \| None`	Select the quality for constant quality mode (from -1 to FLT_MAX) (default -1)	`None`
`crf_max`	`float \| None`	In CRF mode, prevents VBV from lowering quality beyond this point. (from -1 to FLT_MAX) (default -1)	`None`
`qp`	`int \| None`	Constant quantization parameter rate control method (from -1 to INT_MAX) (default -1)	`None`
`aq_mode`	`int \| None \| Literal['none', 'variance', 'autovariance', 'autovariance-biased']`	AQ method (from -1 to INT_MAX) (default -1)	`None`
`aq_strength`	`float \| None`	AQ strength. Reduces blocking and blurring in flat and textured areas. (from -1 to FLT_MAX) (default -1)	`None`
`psy`	`bool \| None`	Use psychovisual optimizations. (default auto)	`None`
`psy_rd`	`str \| None`	Strength of psychovisual optimization, in : format.	`None`
`rc_lookahead`	`int \| None`	Number of frames to look ahead for frametype and ratecontrol (from -1 to INT_MAX) (default -1)	`None`
`weightb`	`bool \| None`	Weighted prediction for B-frames. (default auto)	`None`
`weightp`	`int \| None \| Literal['none', 'simple', 'smart']`	Weighted prediction analysis method. (from -1 to INT_MAX) (default -1)	`None`
`ssim`	`bool \| None`	Calculate and print SSIM stats. (default auto)	`None`
`intra_refresh`	`bool \| None`	Use Periodic Intra Refresh instead of IDR frames. (default auto)	`None`
`bluray_compat`	`bool \| None`	Bluray compatibility workarounds. (default auto)	`None`
`b_bias`	`int \| None`	Influences how often B-frames are used (from INT_MIN to INT_MAX) (default INT_MIN)	`None`
`b_pyramid`	`int \| None \| Literal['none', 'strict', 'normal']`	Keep some B-frames as references. (from -1 to INT_MAX) (default -1)	`None`
`mixed_refs`	`bool \| None`	One reference per partition, as opposed to one reference per macroblock (default auto)	`None`
`_8x8dct`	`bool \| None`	High profile 8x8 transform. (default auto)	`None`
`fast_pskip`	`bool \| None`	(default auto)	`None`
`aud`	`bool \| None`	Use access unit delimiters. (default auto)	`None`
`mbtree`	`bool \| None`	Use macroblock tree ratecontrol. (default auto)	`None`
`deblock`	`str \| None`	Loop filter parameters, in form.	`None`
`cplxblur`	`float \| None`	Reduce fluctuations in QP (before curve compression) (from -1 to FLT_MAX) (default -1)	`None`
`partitions`	`str \| None`	A comma-separated list of partitions to consider. Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all	`None`
`direct_pred`	`int \| None \| Literal['none', 'spatial', 'temporal', 'auto']`	Direct MV prediction mode (from -1 to INT_MAX) (default -1)	`None`
`slice_max_size`	`int \| None`	Limit the size of each slice in bytes (from -1 to INT_MAX) (default -1)	`None`
`stats`	`str \| None`	Filename for 2 pass stats	`None`
`nal_hrd`	`int \| None \| Literal['none', 'vbr', 'cbr']`	Signal HRD information (requires vbv-bufsize; cbr not allowed in .mp4) (from -1 to INT_MAX) (default -1)	`None`
`avcintra_class`	`int \| None`	AVC-Intra class 50/100/200/300/480 (from -1 to 480) (default -1)	`None`
`me_method`	`int \| None \| Literal['dia', 'hex', 'umh', 'esa', 'tesa']`	Set motion estimation method (from -1 to 4) (default -1)	`None`
`forced_idr`	`bool \| None`	If forcing keyframes, force them as IDR frames. (default false)	`None`
`coder`	`int \| None \| Literal['default', 'cavlc', 'cabac', 'vlc', 'ac']`	Coder type (from -1 to 1) (default default)	`None`
`b_strategy`	`int \| None`	Strategy to choose between I/P/B-frames (from -1 to 2) (default -1)	`None`
`chromaoffset`	`int \| None`	QP difference between chroma and luma (from INT_MIN to INT_MAX) (default 0)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default -1)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default -1)	`None`
`udu_sei`	`bool \| None`	Use user data unregistered SEI if available (default false)	`None`
`x264_params`	`str \| None`	Override the x264 configuration using a :-separated list of key=value parameters	`None`
`mb_info`	`bool \| None`	Set mb_info data through AVSideData, only useful when used from the API (default false)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libx265 ¶

libx265(
    crf: float | None = None,
    qp: int | None = None,
    forced_idr: bool | None = None,
    preset: str | None = None,
    tune: str | None = None,
    profile: str | None = None,
    udu_sei: bool | None = None,
    a53cc: bool | None = None,
    x265_params: str | None = None,
) -> FFMpegEncoderOption

(codec hevc)

Parameters:

Name	Type	Description	Default
`crf`	`float \| None`	set the x265 crf (from -1 to FLT_MAX) (default -1)	`None`
`qp`	`int \| None`	set the x265 qp (from -1 to INT_MAX) (default -1)	`None`
`forced_idr`	`bool \| None`	if forcing keyframes, force them as IDR frames (default false)	`None`
`preset`	`str \| None`	set the x265 preset	`None`
`tune`	`str \| None`	set the x265 tune parameter	`None`
`profile`	`str \| None`	set the x265 profile	`None`
`udu_sei`	`bool \| None`	Use user data unregistered SEI if available (default false)	`None`
`a53cc`	`bool \| None`	Use A53 Closed Captions (if available) (default true)	`None`
`x265_params`	`str \| None`	set the x265 configuration using a :-separated list of key=value parameters	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

libxvid ¶

libxvid(
    lumi_aq: int | None = None,
    variance_aq: int | None = None,
    ssim: (
        int | None | Literal["off", "avg", "frame"]
    ) = None,
    ssim_acc: int | None = None,
    gmc: int | None = None,
    me_quality: int | None = None,
    mpeg_quant: int | None = None,
) -> FFMpegEncoderOption

(codec mpeg4)

Parameters:

Name	Type	Description	Default
`lumi_aq`	`int \| None`	Luminance masking AQ (from 0 to 1) (default 0)	`None`
`variance_aq`	`int \| None`	Variance AQ (from 0 to 1) (default 0)	`None`
`ssim`	`int \| None \| Literal['off', 'avg', 'frame']`	Show SSIM information to stdout (from 0 to 2) (default off)	`None`
`ssim_acc`	`int \| None`	SSIM accuracy (from 0 to 4) (default 2)	`None`
`gmc`	`int \| None`	use GMC (from 0 to 1) (default 0)	`None`
`me_quality`	`int \| None`	Motion estimation quality (from 0 to 6) (default 4)	`None`
`mpeg_quant`	`int \| None`	Use MPEG quantizers instead of H.263 (from 0 to 1) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

ljpeg ¶

ljpeg(
    pred: (
        int | None | Literal["left", "plane", "median"]
    ) = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`pred`	`int \| None \| Literal['left', 'plane', 'median']`	Prediction method (from 1 to 3) (default left)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

magicyuv ¶

magicyuv(
    pred: (
        int | None | Literal["left", "gradient", "median"]
    ) = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`pred`	`int \| None \| Literal['left', 'gradient', 'median']`	Prediction method (from 1 to 3) (default left)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

mjpeg ¶

mjpeg(
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    huffman: (
        int | None | Literal["default", "optimal"]
    ) = None,
    force_duplicated_matrix: bool | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`huffman`	`int \| None \| Literal['default', 'optimal']`	Huffman table strategy (from 0 to 1) (default optimal)	`None`
`force_duplicated_matrix`	`bool \| None`	Always write luma and chroma matrix for mjpeg, useful for rtp streaming. (default false)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

mjpeg_vaapi ¶

mjpeg_vaapi(
    low_power: bool | None = None,
    idr_interval: int | None = None,
    b_depth: int | None = None,
    async_depth: int | None = None,
    max_frame_size: int | None = None,
    jfif: bool | None = None,
    huffman: bool | None = None,
) -> FFMpegEncoderOption

(codec mjpeg)

Parameters:

Name	Type	Description	Default
`low_power`	`bool \| None`	Use low-power encoding mode (only available on some platforms; may not support all encoding features) (default false)	`None`
`idr_interval`	`int \| None`	Distance (in I-frames) between IDR frames (from 0 to INT_MAX) (default 0)	`None`
`b_depth`	`int \| None`	Maximum B-frame reference depth (from 1 to INT_MAX) (default 1)	`None`
`async_depth`	`int \| None`	Maximum processing parallelism. Increase this to improve single channel performance. This option doesn't work if driver doesn't implement vaSyncBuffer function. (from 1 to 64) (default 2)	`None`
`max_frame_size`	`int \| None`	Maximum frame size (in bytes) (from 0 to INT_MAX) (default 0)	`None`
`jfif`	`bool \| None`	Include JFIF header (default false)	`None`
`huffman`	`bool \| None`	Include huffman tables (default true)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

mlp ¶

mlp(
    max_interval: int | None = None,
    lpc_coeff_precision: int | None = None,
    lpc_type: (
        int | None | Literal["levinson", "cholesky"]
    ) = None,
    lpc_passes: int | None = None,
    codebook_search: int | None = None,
    prediction_order: (
        int | None | Literal["estimation", "search"]
    ) = None,
    rematrix_precision: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`max_interval`	`int \| None`	Max number of frames between each new header (from 8 to 128) (default 16)	`None`
`lpc_coeff_precision`	`int \| None`	LPC coefficient precision (from 0 to 15) (default 15)	`None`
`lpc_type`	`int \| None \| Literal['levinson', 'cholesky']`	LPC algorithm (from 2 to 3) (default levinson)	`None`
`lpc_passes`	`int \| None`	Number of passes to use for Cholesky factorization during LPC analysis (from 1 to INT_MAX) (default 2)	`None`
`codebook_search`	`int \| None`	Max number of codebook searches (from 1 to 100) (default 3)	`None`
`prediction_order`	`int \| None \| Literal['estimation', 'search']`	Search method for selecting prediction order (from 0 to 4) (default estimation)	`None`
`rematrix_precision`	`int \| None`	Rematrix coefficient precision (from 0 to 14) (default 1)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

mov_text ¶

mov_text(height: int | None = None) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`height`	`int \| None`	Frame height, usually video height (from 0 to INT_MAX) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

mp2 ¶

mp2() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

mp2fixed ¶

mp2fixed() -> FFMpegEncoderOption

(codec mp2)

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

mpeg1video ¶

mpeg1video(
    gop_timecode: str | None = None,
    drop_frame_timecode: bool | None = None,
    scan_offset: bool | None = None,
    timecode_frame_start: int | None = None,
    b_strategy: int | None = None,
    b_sensitivity: int | None = None,
    brd_scale: int | None = None,
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`gop_timecode`	`str \| None`	MPEG GOP Timecode in hh:mm:ss[:;.]ff format. Overrides timecode_frame_start.	`None`
`drop_frame_timecode`	`bool \| None`	Timecode is in drop frame format. (default false)	`None`
`scan_offset`	`bool \| None`	Reserve space for SVCD scan offset user data. (default false)	`None`
`timecode_frame_start`	`int \| None`	GOP timecode frame start number, in non-drop-frame format (from -1 to I64_MAX) (default -1)	`None`
`b_strategy`	`int \| None`	Strategy to choose between I/P/B-frames (from 0 to 2) (default 0)	`None`
`b_sensitivity`	`int \| None`	Adjust sensitivity of b_frame_strategy 1 (from 1 to INT_MAX) (default 40)	`None`
`brd_scale`	`int \| None`	Downscale frames for dynamic B-frame decision (from 0 to 3) (default 0)	`None`
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

mpeg2_vaapi ¶

mpeg2_vaapi(
    low_power: bool | None = None,
    idr_interval: int | None = None,
    b_depth: int | None = None,
    async_depth: int | None = None,
    max_frame_size: int | None = None,
    rc_mode: (
        int
        | None
        | Literal[
            "auto",
            "CQP",
            "CBR",
            "VBR",
            "ICQ",
            "QVBR",
            "AVBR",
        ]
    ) = None,
    profile: int | None | Literal["simple", "main"] = None,
    level: (
        int
        | None
        | Literal["low", "main", "high_1440", "high"]
    ) = None,
) -> FFMpegEncoderOption

(codec mpeg2video)

Parameters:

Name	Type	Description	Default
`low_power`	`bool \| None`	Use low-power encoding mode (only available on some platforms; may not support all encoding features) (default false)	`None`
`idr_interval`	`int \| None`	Distance (in I-frames) between IDR frames (from 0 to INT_MAX) (default 0)	`None`
`b_depth`	`int \| None`	Maximum B-frame reference depth (from 1 to INT_MAX) (default 1)	`None`
`async_depth`	`int \| None`	Maximum processing parallelism. Increase this to improve single channel performance. This option doesn't work if driver doesn't implement vaSyncBuffer function. (from 1 to 64) (default 2)	`None`
`max_frame_size`	`int \| None`	Maximum frame size (in bytes) (from 0 to INT_MAX) (default 0)	`None`
`rc_mode`	`int \| None \| Literal['auto', 'CQP', 'CBR', 'VBR', 'ICQ', 'QVBR', 'AVBR']`	Set rate control mode (from 0 to 6) (default auto)	`None`
`profile`	`int \| None \| Literal['simple', 'main']`	Set profile (in profile_and_level_indication) (from -99 to 7) (default -99)	`None`
`level`	`int \| None \| Literal['low', 'main', 'high_1440', 'high']`	Set level (in profile_and_level_indication) (from 0 to 15) (default high)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

mpeg2video ¶

mpeg2video(
    gop_timecode: str | None = None,
    drop_frame_timecode: bool | None = None,
    scan_offset: bool | None = None,
    timecode_frame_start: int | None = None,
    b_strategy: int | None = None,
    b_sensitivity: int | None = None,
    brd_scale: int | None = None,
    intra_vlc: bool | None = None,
    non_linear_quant: bool | None = None,
    alternate_scan: bool | None = None,
    a53cc: bool | None = None,
    seq_disp_ext: (
        int | None | Literal["auto", "never", "always"]
    ) = None,
    video_format: (
        int
        | None
        | Literal[
            "component",
            "pal",
            "ntsc",
            "secam",
            "mac",
            "unspecified",
        ]
    ) = None,
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`gop_timecode`	`str \| None`	MPEG GOP Timecode in hh:mm:ss[:;.]ff format. Overrides timecode_frame_start.	`None`
`drop_frame_timecode`	`bool \| None`	Timecode is in drop frame format. (default false)	`None`
`scan_offset`	`bool \| None`	Reserve space for SVCD scan offset user data. (default false)	`None`
`timecode_frame_start`	`int \| None`	GOP timecode frame start number, in non-drop-frame format (from -1 to I64_MAX) (default -1)	`None`
`b_strategy`	`int \| None`	Strategy to choose between I/P/B-frames (from 0 to 2) (default 0)	`None`
`b_sensitivity`	`int \| None`	Adjust sensitivity of b_frame_strategy 1 (from 1 to INT_MAX) (default 40)	`None`
`brd_scale`	`int \| None`	Downscale frames for dynamic B-frame decision (from 0 to 3) (default 0)	`None`
`intra_vlc`	`bool \| None`	Use MPEG-2 intra VLC table. (default false)	`None`
`non_linear_quant`	`bool \| None`	Use nonlinear quantizer. (default false)	`None`
`alternate_scan`	`bool \| None`	Enable alternate scantable. (default false)	`None`
`a53cc`	`bool \| None`	Use A53 Closed Captions (if available) (default true)	`None`
`seq_disp_ext`	`int \| None \| Literal['auto', 'never', 'always']`	Write sequence_display_extension blocks. (from -1 to 1) (default auto)	`None`
`video_format`	`int \| None \| Literal['component', 'pal', 'ntsc', 'secam', 'mac', 'unspecified']`	Video_format in the sequence_display_extension indicating the source of the video. (from 0 to 7) (default unspecified)	`None`
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

mpeg4 ¶

mpeg4(
    data_partitioning: bool | None = None,
    alternate_scan: bool | None = None,
    mpeg_quant: int | None = None,
    b_strategy: int | None = None,
    b_sensitivity: int | None = None,
    brd_scale: int | None = None,
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`data_partitioning`	`bool \| None`	Use data partitioning. (default false)	`None`
`alternate_scan`	`bool \| None`	Enable alternate scantable. (default false)	`None`
`mpeg_quant`	`int \| None`	Use MPEG quantizers instead of H.263 (from 0 to 1) (default 0)	`None`
`b_strategy`	`int \| None`	Strategy to choose between I/P/B-frames (from 0 to 2) (default 0)	`None`
`b_sensitivity`	`int \| None`	Adjust sensitivity of b_frame_strategy 1 (from 1 to INT_MAX) (default 40)	`None`
`brd_scale`	`int \| None`	Downscale frames for dynamic B-frame decision (from 0 to 3) (default 0)	`None`
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

mpeg4_v4l2m2m ¶

mpeg4_v4l2m2m(
    num_output_buffers: int | None = None,
    num_capture_buffers: int | None = None,
) -> FFMpegEncoderOption

(codec mpeg4)

Parameters:

Name	Type	Description	Default
`num_output_buffers`	`int \| None`	Number of buffers in the output context (from 2 to INT_MAX) (default 16)	`None`
`num_capture_buffers`	`int \| None`	Number of buffers in the capture context (from 4 to INT_MAX) (default 4)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

msmpeg4 ¶

msmpeg4(
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

(codec msmpeg4v3)

Parameters:

Name	Type	Description	Default
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

msmpeg4v2 ¶

msmpeg4v2(
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

msrle ¶

msrle() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

msvideo1 ¶

msvideo1() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

nellymoser ¶

nellymoser() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

opus ¶

opus(
    opus_delay: float | None = None,
    apply_phase_inv: bool | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`opus_delay`	`float \| None`	Maximum delay in milliseconds (from 2.5 to 360) (default 360)	`None`
`apply_phase_inv`	`bool \| None`	Apply intensity stereo phase inversion (default true)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pam ¶

pam() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pbm ¶

pbm() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_alaw ¶

pcm_alaw() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_bluray ¶

pcm_bluray() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_dvd ¶

pcm_dvd() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_f32be ¶

pcm_f32be() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_f32le ¶

pcm_f32le() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_f64be ¶

pcm_f64be() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_f64le ¶

pcm_f64le() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_mulaw ¶

pcm_mulaw() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s16be ¶

pcm_s16be() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s16be_planar ¶

pcm_s16be_planar() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s16le ¶

pcm_s16le() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s16le_planar ¶

pcm_s16le_planar() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s24be ¶

pcm_s24be() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s24daud ¶

pcm_s24daud() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s24le ¶

pcm_s24le() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s24le_planar ¶

pcm_s24le_planar() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s32be ¶

pcm_s32be() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s32le ¶

pcm_s32le() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s32le_planar ¶

pcm_s32le_planar() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s64be ¶

pcm_s64be() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s64le ¶

pcm_s64le() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s8 ¶

pcm_s8() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_s8_planar ¶

pcm_s8_planar() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_u16be ¶

pcm_u16be() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_u16le ¶

pcm_u16le() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_u24be ¶

pcm_u24be() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_u24le ¶

pcm_u24le() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_u32be ¶

pcm_u32be() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_u32le ¶

pcm_u32le() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_u8 ¶

pcm_u8() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcm_vidc ¶

pcm_vidc() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pcx ¶

pcx() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pfm ¶

pfm() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pgm ¶

pgm() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

pgmyuv ¶

pgmyuv() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

phm ¶

phm() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

png ¶

png(
    dpi: int | None = None,
    dpm: int | None = None,
    pred: (
        int
        | None
        | Literal[
            "none", "sub", "up", "avg", "paeth", "mixed"
        ]
    ) = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`dpi`	`int \| None`	Set image resolution (in dots per inch) (from 0 to 65536) (default 0)	`None`
`dpm`	`int \| None`	Set image resolution (in dots per meter) (from 0 to 65536) (default 0)	`None`
`pred`	`int \| None \| Literal['none', 'sub', 'up', 'avg', 'paeth', 'mixed']`	Prediction method (from 0 to 5) (default none)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

ppm ¶

ppm() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

prores ¶

prores(vendor: str | None = None) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`vendor`	`str \| None`	vendor ID (default "fmpg")	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

prores_aw ¶

prores_aw(vendor: str | None = None) -> FFMpegEncoderOption

(codec prores)

Parameters:

Name	Type	Description	Default
`vendor`	`str \| None`	vendor ID (default "fmpg")	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

prores_ks ¶

prores_ks(
    mbs_per_slice: int | None = None,
    profile: (
        int
        | None
        | Literal[
            "auto",
            "proxy",
            "lt",
            "standard",
            "hq",
            "4444",
            "4444xq",
        ]
    ) = None,
    vendor: str | None = None,
    bits_per_mb: int | None = None,
    quant_mat: (
        int
        | None
        | Literal[
            "auto",
            "proxy",
            "lt",
            "standard",
            "hq",
            "default",
        ]
    ) = None,
    alpha_bits: int | None = None,
) -> FFMpegEncoderOption

(codec prores)

Parameters:

Name	Type	Description	Default
`mbs_per_slice`	`int \| None`	macroblocks per slice (from 1 to 8) (default 8)	`None`
`profile`	`int \| None \| Literal['auto', 'proxy', 'lt', 'standard', 'hq', '4444', '4444xq']`	(from -1 to 5) (default auto)	`None`
`vendor`	`str \| None`	vendor ID (default "Lavc")	`None`
`bits_per_mb`	`int \| None`	desired bits per macroblock (from 0 to 8192) (default 0)	`None`
`quant_mat`	`int \| None \| Literal['auto', 'proxy', 'lt', 'standard', 'hq', 'default']`	quantiser matrix (from -1 to 6) (default auto)	`None`
`alpha_bits`	`int \| None`	bits for alpha plane (from 0 to 16) (default 16)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

qoi ¶

qoi() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

qtrle ¶

qtrle() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

r10k ¶

r10k() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

r210 ¶

r210() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

rawvideo ¶

rawvideo() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

real_144 ¶

real_144() -> FFMpegEncoderOption

(codec ra_144)

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

roq_dpcm ¶

roq_dpcm() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

roqvideo ¶

roqvideo(
    quake3_compat: bool | None = None,
) -> FFMpegEncoderOption

(codec roq)

Parameters:

Name	Type	Description	Default
`quake3_compat`	`bool \| None`	Whether to respect known limitations in Quake 3 decoder (default true)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

rpza ¶

rpza(
    skip_frame_thresh: int | None = None,
    continue_one_color_thresh: int | None = None,
    sixteen_color_thresh: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`skip_frame_thresh`	`int \| None`	(from 0 to 24) (default 1)	`None`
`continue_one_color_thresh`	`int \| None`	(from 0 to 24) (default 0)	`None`
`sixteen_color_thresh`	`int \| None`	(from 0 to 24) (default 1)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

rv10 ¶

rv10(
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

rv20 ¶

rv20(
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

s302m ¶

s302m() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

sbc ¶

sbc(
    sbc_delay: str | None = None, msbc: bool | None = None
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`sbc_delay`	`str \| None`	set maximum algorithmic latency (default 0.013)	`None`
`msbc`	`bool \| None`	use mSBC mode (wideband speech mono SBC) (default false)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

sgi ¶

sgi(rle: int | None = None) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`rle`	`int \| None`	Use run-length compression (from 0 to 1) (default 1)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

smc ¶

smc() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

snow ¶

snow(
    motion_est: (
        int | None | Literal["zero", "epzs", "xone", "iter"]
    ) = None,
    memc_only: bool | None = None,
    no_bitstream: bool | None = None,
    intra_penalty: int | None = None,
    iterative_dia_size: int | None = None,
    sc_threshold: int | None = None,
    pred: int | None | Literal["dwt97", "dwt53"] = None,
    rc_eq: str | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone', 'iter']`	motion estimation algorithm (from 0 to 3) (default epzs)	`None`
`memc_only`	`bool \| None`	Only do ME/MC (I frames -> ref, P frame -> ME+MC). (default false)	`None`
`no_bitstream`	`bool \| None`	Skip final bitstream writeout. (default false)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decission (from 0 to INT_MAX) (default 0)	`None`
`iterative_dia_size`	`int \| None`	Dia size for the iterative ME (from 0 to INT_MAX) (default 0)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`pred`	`int \| None \| Literal['dwt97', 'dwt53']`	Spatial decomposition type (from 0 to 1) (default dwt97)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

sonic ¶

sonic() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

sonicls ¶

sonicls() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

speedhq ¶

speedhq(
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

srt ¶

srt() -> FFMpegEncoderOption

(codec subrip)

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

ssa ¶

ssa() -> FFMpegEncoderOption

(codec ass)

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

subrip ¶

subrip() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

sunrast ¶

sunrast(rle: int | None = None) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`rle`	`int \| None`	Use run-length compression (from 0 to 1) (default 1)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

svq1 ¶

svq1(
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	Motion estimation algorithm (from 0 to 2) (default epzs)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

targa ¶

targa(rle: int | None = None) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`rle`	`int \| None`	Use run-length compression (from 0 to 1) (default 1)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

text ¶

text() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

tiff ¶

tiff(
    dpi: int | None = None,
    compression_algo: (
        int
        | None
        | Literal["packbits", "raw", "lzw", "deflate"]
    ) = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`dpi`	`int \| None`	set the image resolution (in dpi) (from 1 to 65536) (default 72)	`None`
`compression_algo`	`int \| None \| Literal['packbits', 'raw', 'lzw', 'deflate']`	(from 1 to 32946) (default packbits)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

truehd ¶

truehd(
    max_interval: int | None = None,
    lpc_coeff_precision: int | None = None,
    lpc_type: (
        int | None | Literal["levinson", "cholesky"]
    ) = None,
    lpc_passes: int | None = None,
    codebook_search: int | None = None,
    prediction_order: (
        int | None | Literal["estimation", "search"]
    ) = None,
    rematrix_precision: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`max_interval`	`int \| None`	Max number of frames between each new header (from 8 to 128) (default 16)	`None`
`lpc_coeff_precision`	`int \| None`	LPC coefficient precision (from 0 to 15) (default 15)	`None`
`lpc_type`	`int \| None \| Literal['levinson', 'cholesky']`	LPC algorithm (from 2 to 3) (default levinson)	`None`
`lpc_passes`	`int \| None`	Number of passes to use for Cholesky factorization during LPC analysis (from 1 to INT_MAX) (default 2)	`None`
`codebook_search`	`int \| None`	Max number of codebook searches (from 1 to 100) (default 3)	`None`
`prediction_order`	`int \| None \| Literal['estimation', 'search']`	Search method for selecting prediction order (from 0 to 4) (default estimation)	`None`
`rematrix_precision`	`int \| None`	Rematrix coefficient precision (from 0 to 14) (default 1)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

tta ¶

tta() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

ttml ¶

ttml() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

utvideo ¶

utvideo(
    pred: (
        int
        | None
        | Literal["none", "left", "gradient", "median"]
    ) = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`pred`	`int \| None \| Literal['none', 'left', 'gradient', 'median']`	Prediction method (from 0 to 3) (default left)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

v210 ¶

v210() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

v308 ¶

v308() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

v408 ¶

v408() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

v410 ¶

v410() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

vbn ¶

vbn(
    format: (
        int | None | Literal["raw", "dxt1", "dxt5"]
    ) = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`format`	`int \| None \| Literal['raw', 'dxt1', 'dxt5']`	Texture format (from 0 to 3) (default dxt5)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

vc2 ¶

vc2(
    tolerance: float | None = None,
    slice_width: int | None = None,
    slice_height: int | None = None,
    wavelet_depth: int | None = None,
    wavelet_type: (
        int
        | None
        | Literal["9_7", "5_3", "haar", "haar_noshift"]
    ) = None,
    qm: (
        int | None | Literal["default", "color", "flat"]
    ) = None,
) -> FFMpegEncoderOption

(codec dirac)

Parameters:

Name	Type	Description	Default
`tolerance`	`float \| None`	Max undershoot in percent (from 0 to 45) (default 5)	`None`
`slice_width`	`int \| None`	Slice width (from 32 to 1024) (default 32)	`None`
`slice_height`	`int \| None`	Slice height (from 8 to 1024) (default 16)	`None`
`wavelet_depth`	`int \| None`	Transform depth (from 1 to 5) (default 4)	`None`
`wavelet_type`	`int \| None \| Literal['9_7', '5_3', 'haar', 'haar_noshift']`	Transform type (from 0 to 7) (default 9_7)	`None`
`qm`	`int \| None \| Literal['default', 'color', 'flat']`	Custom quantization matrix (from 0 to 3) (default default)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

vnull ¶

vnull() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

vorbis ¶

vorbis() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

vp8_v4l2m2m ¶

vp8_v4l2m2m(
    num_output_buffers: int | None = None,
    num_capture_buffers: int | None = None,
) -> FFMpegEncoderOption

(codec vp8)

Parameters:

Name	Type	Description	Default
`num_output_buffers`	`int \| None`	Number of buffers in the output context (from 2 to INT_MAX) (default 16)	`None`
`num_capture_buffers`	`int \| None`	Number of buffers in the capture context (from 4 to INT_MAX) (default 4)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

vp8_vaapi ¶

vp8_vaapi(
    low_power: bool | None = None,
    idr_interval: int | None = None,
    b_depth: int | None = None,
    async_depth: int | None = None,
    max_frame_size: int | None = None,
    rc_mode: (
        int
        | None
        | Literal[
            "auto",
            "CQP",
            "CBR",
            "VBR",
            "ICQ",
            "QVBR",
            "AVBR",
        ]
    ) = None,
    loop_filter_level: int | None = None,
    loop_filter_sharpness: int | None = None,
) -> FFMpegEncoderOption

(codec vp8)

Parameters:

Name	Type	Description	Default
`low_power`	`bool \| None`	Use low-power encoding mode (only available on some platforms; may not support all encoding features) (default false)	`None`
`idr_interval`	`int \| None`	Distance (in I-frames) between IDR frames (from 0 to INT_MAX) (default 0)	`None`
`b_depth`	`int \| None`	Maximum B-frame reference depth (from 1 to INT_MAX) (default 1)	`None`
`async_depth`	`int \| None`	Maximum processing parallelism. Increase this to improve single channel performance. This option doesn't work if driver doesn't implement vaSyncBuffer function. (from 1 to 64) (default 2)	`None`
`max_frame_size`	`int \| None`	Maximum frame size (in bytes) (from 0 to INT_MAX) (default 0)	`None`
`rc_mode`	`int \| None \| Literal['auto', 'CQP', 'CBR', 'VBR', 'ICQ', 'QVBR', 'AVBR']`	Set rate control mode (from 0 to 6) (default auto)	`None`
`loop_filter_level`	`int \| None`	Loop filter level (from 0 to 63) (default 16)	`None`
`loop_filter_sharpness`	`int \| None`	Loop filter sharpness (from 0 to 15) (default 4)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

vp9_vaapi ¶

vp9_vaapi(
    low_power: bool | None = None,
    idr_interval: int | None = None,
    b_depth: int | None = None,
    async_depth: int | None = None,
    max_frame_size: int | None = None,
    rc_mode: (
        int
        | None
        | Literal[
            "auto",
            "CQP",
            "CBR",
            "VBR",
            "ICQ",
            "QVBR",
            "AVBR",
        ]
    ) = None,
    loop_filter_level: int | None = None,
    loop_filter_sharpness: int | None = None,
) -> FFMpegEncoderOption

(codec vp9)

Parameters:

Name	Type	Description	Default
`low_power`	`bool \| None`	Use low-power encoding mode (only available on some platforms; may not support all encoding features) (default false)	`None`
`idr_interval`	`int \| None`	Distance (in I-frames) between IDR frames (from 0 to INT_MAX) (default 0)	`None`
`b_depth`	`int \| None`	Maximum B-frame reference depth (from 1 to INT_MAX) (default 1)	`None`
`async_depth`	`int \| None`	Maximum processing parallelism. Increase this to improve single channel performance. This option doesn't work if driver doesn't implement vaSyncBuffer function. (from 1 to 64) (default 2)	`None`
`max_frame_size`	`int \| None`	Maximum frame size (in bytes) (from 0 to INT_MAX) (default 0)	`None`
`rc_mode`	`int \| None \| Literal['auto', 'CQP', 'CBR', 'VBR', 'ICQ', 'QVBR', 'AVBR']`	Set rate control mode (from 0 to 6) (default auto)	`None`
`loop_filter_level`	`int \| None`	Loop filter level (from 0 to 63) (default 16)	`None`
`loop_filter_sharpness`	`int \| None`	Loop filter sharpness (from 0 to 15) (default 4)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

wavpack ¶

wavpack(
    joint_stereo: bool | None = None,
    optimize_mono: bool | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`joint_stereo`	`bool \| None`	(default auto)	`None`
`optimize_mono`	`bool \| None`	(default false)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

wbmp ¶

wbmp() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

webvtt ¶

webvtt() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

wmav1 ¶

wmav1() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

wmav2 ¶

wmav2() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

wmv1 ¶

wmv1(
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

wmv2 ¶

wmv2(
    mpv_flags: str | None = None,
    luma_elim_threshold: int | None = None,
    chroma_elim_threshold: int | None = None,
    quantizer_noise_shaping: int | None = None,
    error_rate: int | None = None,
    qsquish: float | None = None,
    rc_qmod_amp: float | None = None,
    rc_qmod_freq: int | None = None,
    rc_eq: str | None = None,
    rc_init_cplx: float | None = None,
    rc_buf_aggressivity: float | None = None,
    border_mask: float | None = None,
    lmin: int | None = None,
    lmax: int | None = None,
    skip_threshold: int | None = None,
    skip_factor: int | None = None,
    skip_exp: int | None = None,
    skip_cmp: (
        int
        | None
        | Literal[
            "sad",
            "sse",
            "satd",
            "dct",
            "psnr",
            "bit",
            "rd",
            "zero",
            "vsad",
            "vsse",
            "nsse",
            "dct264",
            "dctmax",
            "chroma",
            "msad",
        ]
    ) = None,
    sc_threshold: int | None = None,
    noise_reduction: int | None = None,
    ps: int | None = None,
    motion_est: (
        int | None | Literal["zero", "epzs", "xone"]
    ) = None,
    mepc: int | None = None,
    mepre: int | None = None,
    intra_penalty: int | None = None,
) -> FFMpegEncoderOption

Parameters:

Name	Type	Description	Default
`mpv_flags`	`str \| None`	Flags common for all mpegvideo-based encoders. (default 0)	`None`
`luma_elim_threshold`	`int \| None`	single coefficient elimination threshold for luminance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`chroma_elim_threshold`	`int \| None`	single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) (from INT_MIN to INT_MAX) (default 0)	`None`
`quantizer_noise_shaping`	`int \| None`	(from 0 to INT_MAX) (default 0)	`None`
`error_rate`	`int \| None`	Simulate errors in the bitstream to test error concealment. (from 0 to INT_MAX) (default 0)	`None`
`qsquish`	`float \| None`	how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function) (from 0 to 99) (default 0)	`None`
`rc_qmod_amp`	`float \| None`	experimental quantizer modulation (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_qmod_freq`	`int \| None`	experimental quantizer modulation (from INT_MIN to INT_MAX) (default 0)	`None`
`rc_eq`	`str \| None`	Set rate control equation. When computing the expression, besides the standard functions defined in the section 'Expression Evaluation', the following functions are available: bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.	`None`
`rc_init_cplx`	`float \| None`	initial complexity for 1-pass encoding (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`rc_buf_aggressivity`	`float \| None`	currently useless (from -FLT_MAX to FLT_MAX) (default 1)	`None`
`border_mask`	`float \| None`	increase the quantizer for macroblocks close to borders (from -FLT_MAX to FLT_MAX) (default 0)	`None`
`lmin`	`int \| None`	minimum Lagrange factor (VBR) (from 0 to INT_MAX) (default 236)	`None`
`lmax`	`int \| None`	maximum Lagrange factor (VBR) (from 0 to INT_MAX) (default 3658)	`None`
`skip_threshold`	`int \| None`	Frame skip threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_factor`	`int \| None`	Frame skip factor (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_exp`	`int \| None`	Frame skip exponent (from INT_MIN to INT_MAX) (default 0)	`None`
`skip_cmp`	`int \| None \| Literal['sad', 'sse', 'satd', 'dct', 'psnr', 'bit', 'rd', 'zero', 'vsad', 'vsse', 'nsse', 'dct264', 'dctmax', 'chroma', 'msad']`	Frame skip compare function (from INT_MIN to INT_MAX) (default dctmax)	`None`
`sc_threshold`	`int \| None`	Scene change threshold (from INT_MIN to INT_MAX) (default 0)	`None`
`noise_reduction`	`int \| None`	Noise reduction (from INT_MIN to INT_MAX) (default 0)	`None`
`ps`	`int \| None`	RTP payload size in bytes (from INT_MIN to INT_MAX) (default 0)	`None`
`motion_est`	`int \| None \| Literal['zero', 'epzs', 'xone']`	motion estimation algorithm (from 0 to 2) (default epzs)	`None`
`mepc`	`int \| None`	Motion estimation bitrate penalty compensation (1.0 = 256) (from INT_MIN to INT_MAX) (default 256)	`None`
`mepre`	`int \| None`	pre motion estimation (from INT_MIN to INT_MAX) (default 0)	`None`
`intra_penalty`	`int \| None`	Penalty for intra blocks in block decision (from 0 to 1.07374e+09) (default 0)	`None`

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

wrapped_avframe ¶

wrapped_avframe() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

xbm ¶

xbm() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

xface ¶

xface() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

xsub ¶

xsub() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

xwd ¶

xwd() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

y41p ¶

y41p() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

yuv4 ¶

yuv4() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

zlib ¶

zlib() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options

zmbv ¶

zmbv() -> FFMpegEncoderOption

Returns:

Type	Description
`FFMpegEncoderOption`	the set codec options