zprp_ffmpeg

zprp_ffmpeg.compile(stream: Stream, cmd: str = 'ffmpeg', overwrite_output: bool = False) → List[str]

Returns command-line for invoking ffmpeg split by space

zprp_ffmpeg.filter(stream_spec: Stream, filter_name: str, *args, **kwargs) → Stream

Applies a custom filter

zprp_ffmpeg.get_args(stream: Stream, overwrite_output: bool = False) → List[str]

Build command-line arguments to be passed to ffmpeg.

zprp_ffmpeg.global_args(stream: Stream, *args) → Stream

zprp_ffmpeg.input(filename: str) → Stream

zprp_ffmpeg.output(stream: Stream, filename: str) → Stream

zprp_ffmpeg.overwrite_output(stream: Stream) → Stream

zprp_ffmpeg.probe(filename: str, format='json', **kwargs) → str

Calls ffprobe on given filename and returns output as string.

Parameters:

• filename – the graph to compile

• format – format of output stream. Available options: ‘json’, ‘default’, ‘flat’, ‘csv’, ‘ini’, ‘xml’ (default: json)

Returns:

ffprobe output in given format

zprp_ffmpeg.run(stream: Stream, extra_options: str = '') → Tuple[bytes, bytes]

Returns (stdout,stderr) tuple

zprp_ffmpeg.run_async(stream: Stream) → BaseConnector

Returns handle to a process. Can raise an exception if script tries to terminate before ffmpeg is done.

zprp_ffmpeg.view(graph: Stream, filename=None) → None

Creates graph of filters

filters

zprp_ffmpeg.generated_filters.a3dscope(graph: Stream, rate: str | None = None, size: int | None = None, fov: float | None = None, roll: float | None = None, pitch: float | None = None, yaw: float | None = None, xzoom: float | None = None, yzoom: float | None = None, zzoom: float | None = None, xpos: float | None = None, ypos: float | None = None, zpos: float | None = None, length: int | None = None)

Convert input audio to 3d scope video output.

Parameters:

• rate (str) – set video rate

• size (int) – set video size

• fov (float) – set camera FoV

• roll (float) – set camera roll

• pitch (float) – set camera pitch

• yaw (float) – set camera yaw

• xzoom (float) – set camera zoom

• yzoom (float) – set camera zoom

• zzoom (float) – set camera zoom

• xpos (float) – set camera position

• ypos (float) – set camera position

• zpos (float) – set camera position

• length (int) – set length

zprp_ffmpeg.generated_filters.aap(graph: Stream, order: int | None = None, projection: int | None = None, mu: float | None = None, delta: float | None = None, out_mode: str | None = None, precision: str | None = None)

Apply Affine Projection algorithm to first audio stream.

Parameters:

• order (int) – set the filter order

• projection (int) – set the filter projection

• mu (float) – set the filter mu

• delta (float) – set the filter delta

• out_mode (str) – set output mode possible values: i, d, o, n, e

• precision (str) – set processing precision possible values: auto, float, double

zprp_ffmpeg.generated_filters.abench(graph: Stream, action: str | None = None)

Benchmark part of a filtergraph.

Parameters:

action (str) – set action possible values: start, stop

zprp_ffmpeg.generated_filters.abitscope(graph: Stream, rate: str | None = None, size: int | None = None, colors: str | None = None, mode: str | None = None)

Convert input audio to audio bit scope video output.

Parameters:

• rate (str) – set video rate

• size (int) – set video size

• colors (str) – set channels colors

• mode (str) – set output mode possible values: bars, trace

zprp_ffmpeg.generated_filters.abuffer(graph: Stream, time_base: int | None = None, sample_rate: int | None = None, sample_fmt: str | None = None, channel_layout: str | None = None, channels: int | None = None)

Buffer audio frames, and make them accessible to the filterchain.

zprp_ffmpeg.generated_filters.acompressor(graph: Stream)

Audio compressor.

zprp_ffmpeg.generated_filters.acontrast(graph: Stream, contrast: float | None = None)

Simple audio dynamic range compression/expansion filter.

Parameters:

contrast (float) – set contrast

zprp_ffmpeg.generated_filters.acopy(graph: Stream)

Copy the input audio unchanged to the output.

zprp_ffmpeg.generated_filters.acrossfade(graph: Stream, nb_samples: int | None = None, duration: int | None = None, overlap: bool | None = None, curve1: str | None = None, curve2: int | None = None)

Cross fade two input audio streams.

Parameters:

• nb_samples (int) – set number of samples for cross fade duration

• duration (int) – set cross fade duration

• overlap (bool) – overlap 1st stream end with 2nd stream start

• curve1 (str) – set fade curve type for 1st stream possible values: nofade, tri, qsin, esin, hsin, log, ipar, qua, cub, squ, cbr, par, exp, iqsin, ihsin, dese, desi, losi, sinc, isinc, quat, quatr, qsin2, hsin2

• curve2 (int) – set fade curve type for 2nd stream

zprp_ffmpeg.generated_filters.acrusher(graph: Stream, level_in: float | None = None, level_out: float | None = None, bits: float | None = None, mix: float | None = None, mode: str | None = None, dc: float | None = None, aa: float | None = None, samples: float | None = None, lfo: bool | None = None, lforange: float | None = None, lforate: float | None = None)

Reduce audio bit resolution.

Parameters:

• level_in (float) – set level in

• level_out (float) – set level out

• bits (float) – set bit reduction

• mix (float) – set mix

• mode (str) – set mode possible values: lin, log

• dc (float) – set DC

• aa (float) – set anti-aliasing

• samples (float) – set sample reduction

• lfo (bool) – enable LFO

• lforange (float) – set LFO depth

• lforate (float) – set LFO rate

zprp_ffmpeg.generated_filters.acue(graph: Stream)

Delay filtering to match a cue.

zprp_ffmpeg.generated_filters.addroi(graph: Stream, x: str | None = None, y: str | None = None, w: str | None = None, h: str | None = None, qoffset: int | None = None, clear: bool | None = None)

Add region of interest to frame.

Parameters:

• x (str) – Region distance from left edge of frame.

• y (str) – Region distance from top edge of frame.

• w (str) – Region width.

• h (str) – Region height.

• qoffset (int) – Quantisation offset to apply in the region.

• clear (bool) – Remove any existing regions of interest before adding the new one.

zprp_ffmpeg.generated_filters.adeclick(graph: Stream, window: float | None = None, overlap: float | None = None, arorder: float | None = None, threshold: float | None = None, burst: float | None = None, method: str | None = None)

Remove impulsive noise from input audio.

Parameters:

• window (float) – set window size

• overlap (float) – set window overlap

• arorder (float) – set autoregression order

• threshold (float) – set threshold

• burst (float) – set burst fusion

• method (str) – set overlap method possible values: add, a, save, s

zprp_ffmpeg.generated_filters.adeclip(graph: Stream, window: float | None = None, overlap: float | None = None, arorder: float | None = None, threshold: float | None = None, hsize: int | None = None, method: str | None = None)

Remove clipping from input audio.

Parameters:

• window (float) – set window size

• overlap (float) – set window overlap

• arorder (float) – set autoregression order

• threshold (float) – set threshold

• hsize (int) – set histogram size

• method (str) – set overlap method possible values: add, a, save, s

zprp_ffmpeg.generated_filters.adecorrelate(graph: Stream, stages: int | None = None, seed: int | None = None)

Apply decorrelation to input audio.

Parameters:

• stages (int) – set filtering stages

• seed (int) – set random seed

zprp_ffmpeg.generated_filters.adelay(graph: Stream, delays: str | None = None, all: bool | None = None)

Delay one or more audio channels.

Parameters:

• delays (str) – set list of delays for each channel

• all (bool) – use last available delay for remained channels

zprp_ffmpeg.generated_filters.adenorm(graph: Stream, level: float | None = None, type: str | None = None)

Remedy denormals by adding extremely low-level noise.

Parameters:

• level (float) – set level

• type (str) – set type possible values: dc, ac, square, pulse

zprp_ffmpeg.generated_filters.aderivative(graph: Stream)

Compute derivative of input audio.

zprp_ffmpeg.generated_filters.adrawgraph(graph: Stream)

Draw a graph using input audio metadata.

zprp_ffmpeg.generated_filters.adrc(graph: Stream, transfer: str | None = None, attack: float | None = None, release: float | None = None, channels: str | None = None)

Audio Spectral Dynamic Range Controller.

Parameters:

• transfer (str) – set the transfer expression

• attack (float) – set the attack

• release (float) – set the release

• channels (str) – set channels to filter

zprp_ffmpeg.generated_filters.adynamicequalizer(graph: Stream, threshold: float | None = None, dfrequency: float | None = None, dqfactor: float | None = None, tfrequency: float | None = None, tqfactor: float | None = None, attack: float | None = None, release: float | None = None, ratio: float | None = None, makeup: float | None = None, range: float | None = None, mode: str | None = None, dftype: str | None = None, tftype: str | None = None, auto: str | None = None, precision: str | None = None)

Apply Dynamic Equalization of input audio.

Parameters:

• threshold (float) – set detection threshold

• dfrequency (float) – set detection frequency

• dqfactor (float) – set detection Q factor

• tfrequency (float) – set target frequency

• tqfactor (float) – set target Q factor

• attack (float) – set detection attack duration

• release (float) – set detection release duration

• ratio (float) – set ratio factor

• makeup (float) – set makeup gain

• range (float) – set max gain

• mode (str) – set mode possible values: listen, cutbelow, cutabove, boostbelow, boostabove

• dftype (str) – set detection filter type possible values: bandpass, lowpass, highpass, peak

• tftype (str) – set target filter type possible values: bell, lowshelf, highshelf

• auto (str) – set auto threshold possible values: disabled, off, on, adaptive

• precision (str) – set processing precision possible values: auto, float, double

zprp_ffmpeg.generated_filters.adynamicsmooth(graph: Stream, sensitivity: float | None = None, basefreq: float | None = None)

Apply Dynamic Smoothing of input audio.

Parameters:

• sensitivity (float) – set smooth sensitivity

• basefreq (float) – set base frequency

zprp_ffmpeg.generated_filters.aecho(graph: Stream, in_gain: float | None = None, out_gain: float | None = None, delays: str | None = None, decays: str | None = None)

Add echoing to the audio.

Parameters:

• in_gain (float) – set signal input gain

• out_gain (float) – set signal output gain

• delays (str) – set list of signal delays

• decays (str) – set list of signal decays

zprp_ffmpeg.generated_filters.aemphasis(graph: Stream, level_in: float | None = None, level_out: float | None = None, mode: str | None = None, type: str | None = None)

Audio emphasis.

Parameters:

• level_in (float) – set input gain

• level_out (float) – set output gain

• mode (str) – set filter mode possible values: reproduction, production

• type (str) – set filter type possible values: col, emi, bsi, riaa, cd, 50fm, 75fm, 50kf, 75kf

zprp_ffmpeg.generated_filters.aeval(graph: Stream, exprs: str | None = None, channel_layout: str | None = None)

Filter audio signal according to a specified expression.

Parameters:

• exprs (str) – set the ‘|’-separated list of channels expressions

• channel_layout (str) – set channel layout

zprp_ffmpeg.generated_filters.aevalsrc(graph: Stream, exprs: str | None = None, nb_samples: int | None = None, sample_rate: str | None = None, duration: int | None = None, channel_layout: str | None = None)

Generate an audio signal generated by an expression.

Parameters:

• exprs (str) – set the ‘|’-separated list of channels expressions

• nb_samples (int) – set the number of samples per requested frame

• sample_rate (str) – set the sample rate

• duration (int) – set audio duration

• channel_layout (str) – set channel layout

zprp_ffmpeg.generated_filters.aexciter(graph: Stream, level_in: float | None = None, level_out: float | None = None, amount: float | None = None, drive: float | None = None, blend: float | None = None, freq: float | None = None, ceil: float | None = None, listen: bool | None = None)

Enhance high frequency part of audio.

Parameters:

• level_in (float) – set level in

• level_out (float) – set level out

• amount (float) – set amount

• drive (float) – set harmonics

• blend (float) – set blend harmonics

• freq (float) – set scope

• ceil (float) – set ceiling

• listen (bool) – enable listen mode

zprp_ffmpeg.generated_filters.afade(graph: Stream, type: str | None = None, start_sample: int | None = None, nb_samples: int | None = None, start_time: int | None = None, duration: int | None = None, curve: str | None = None, silence: float | None = None, unity: float | None = None)

Fade in/out input audio.

Parameters:

• type (str) – set the fade direction possible values: in, out

• start_sample (int) – set number of first sample to start fading

• nb_samples (int) – set number of samples for fade duration

• start_time (int) – set time to start fading

• duration (int) – set fade duration

• curve (str) – set fade curve type possible values: nofade, tri, qsin, esin, hsin, log, ipar, qua, cub, squ, cbr, par, exp, iqsin, ihsin, dese, desi, losi, sinc, isinc, quat, quatr, qsin2, hsin2

• silence (float) – set the silence gain

• unity (float) – set the unity gain

zprp_ffmpeg.generated_filters.afdelaysrc(graph: Stream, delay: float | None = None, sample_rate: int | None = None, nb_samples: int | None = None, taps: int | None = None, channel_layout: str | None = None)

Generate a Fractional delay FIR coefficients.

Parameters:

• delay (float) – set fractional delay

• sample_rate (int) – set sample rate

• nb_samples (int) – set the number of samples per requested frame

• taps (int) – set number of taps for delay filter

• channel_layout (str) – set channel layout

zprp_ffmpeg.generated_filters.afftdn(graph: Stream, noise_reduction: float | None = None, noise_floor: float | None = None, noise_type: str | None = None, band_noise: str | None = None, residual_floor: float | None = None, track_noise: bool | None = None, track_residual: bool | None = None, output_mode: str | None = None, adaptivity: float | None = None, floor_offset: float | None = None, noise_link: str | None = None, band_multiplier: float | None = None, sample_noise: str | None = None, gain_smooth: int | None = None)

Denoise audio samples using FFT.

Parameters:

• noise_reduction (float) – set the noise reduction

• noise_floor (float) – set the noise floor

• noise_type (str) – set the noise type possible values: white, w, vinyl, v, shellac, s, custom, c

• band_noise (str) – set the custom bands noise

• residual_floor (float) – set the residual floor

• track_noise (bool) – track noise

• track_residual (bool) – track residual

• output_mode (str) – set output mode possible values: input, i, output, o, noise, n

• adaptivity (float) – set adaptivity factor

• floor_offset (float) – set noise floor offset factor

• noise_link (str) – set the noise floor link possible values: none, min, max, average

• band_multiplier (float) – set band multiplier

• sample_noise (str) – set sample noise mode possible values: none, start, begin, stop, end

• gain_smooth (int) – set gain smooth radius

zprp_ffmpeg.generated_filters.afftfilt(graph: Stream, real: str | None = None, imag: str | None = None, win_size: int | None = None, win_func: str | None = None, overlap: float | None = None)

Apply arbitrary expressions to samples in frequency domain.

Parameters:

• real (str) – set channels real expressions

• imag (str) – set channels imaginary expressions

• win_size (int) – set window size

• win_func (str) – set window function possible values: rect, bartlett, hann, hanning, hamming, blackman, welch, flattop, bharris, bnuttall, bhann, sine, nuttall, lanczos, gauss, tukey, dolph, cauchy, parzen, poisson, bohman, kaiser

• overlap (float) – set window overlap

zprp_ffmpeg.generated_filters.afir(graph: Stream, dry: float | None = None, wet: float | None = None, length: float | None = None, gtype: str | None = None, irnorm: float | None = None, irlink: bool | None = None, irgain: float | None = None, irfmt: str | None = None, maxir: float | None = None, response: bool | None = None, channel: int | None = None, size: int | None = None, rate: str | None = None, minp: int | None = None, maxp: int | None = None, nbirs: int | None = None, ir: int | None = None, precision: str | None = None, irload: str | None = None)

Apply Finite Impulse Response filter with supplied coefficients in additional stream(s).

Parameters:

• dry (float) – set dry gain

• wet (float) – set wet gain

• length (float) – set IR length

• gtype (str) – set IR auto gain type possible values: none, peak, dc, gn, ac, rms

• irnorm (float) – set IR norm

• irlink (bool) – set IR link

• irgain (float) – set IR gain

• irfmt (str) – set IR format possible values: mono, input

• maxir (float) – set max IR length

• response (bool) – show IR frequency response

• channel (int) – set IR channel to display frequency response

• size (int) – set video size

• rate (str) – set video rate

• minp (int) – set min partition size

• maxp (int) – set max partition size

• nbirs (int) – set number of input IRs

• ir (int) – select IR

• precision (str) – set processing precision possible values: auto, float, double

• irload (str) – set IR loading type possible values: init, access

zprp_ffmpeg.generated_filters.afireqsrc(graph: Stream, preset: str | None = None, gains: str | None = None, bands: str | None = None, taps: int | None = None, sample_rate: int | None = None, nb_samples: int | None = None, interp: str | None = None, phase: str | None = None)

Generate a FIR equalizer coefficients audio stream.

Parameters:

• preset (str) – set equalizer preset possible values: custom

• gains (str) – set gain values per band

• bands (str) – set central frequency values per band

• taps (int) – set number of taps

• sample_rate (int) – set sample rate

• nb_samples (int) – set the number of samples per requested frame

• interp (str) – set the interpolation possible values: linear, cubic

• phase (str) – set the phase possible values: linear, min

zprp_ffmpeg.generated_filters.afirsrc(graph: Stream, taps: int | None = None, frequency: str | None = None, magnitude: str | None = None, phase: str | None = None, sample_rate: int | None = None, nb_samples: int | None = None, win_func: str | None = None)

Generate a FIR coefficients audio stream.

Parameters:

• taps (int) – set number of taps

• frequency (str) – set frequency points

• magnitude (str) – set magnitude values

• phase (str) – set phase values

• sample_rate (int) – set sample rate

• nb_samples (int) – set the number of samples per requested frame

• win_func (str) – set window function possible values: rect, bartlett, hann, hanning, hamming, blackman, welch, flattop, bharris, bnuttall, bhann, sine, nuttall, lanczos, gauss, tukey, dolph, cauchy, parzen, poisson, bohman, kaiser

zprp_ffmpeg.generated_filters.aformat(graph: Stream, sample_fmts: str | None = None, sample_rates: str | None = None, channel_layouts: str | None = None)

Convert the input audio to one of the specified formats.

Parameters:

• sample_fmts (str) – A ‘|’-separated list of sample formats.

• sample_rates (str) – A ‘|’-separated list of sample rates.

• channel_layouts (str) – A ‘|’-separated list of channel layouts.

zprp_ffmpeg.generated_filters.afreqshift(graph: Stream, shift: float | None = None, level: float | None = None, order: int | None = None)

Apply frequency shifting to input audio.

Parameters:

• shift (float) – set frequency shift

• level (float) – set output level

• order (int) – set filter order

zprp_ffmpeg.generated_filters.afwtdn(graph: Stream, sigma: float | None = None, levels: int | None = None, wavet: str | None = None, percent: float | None = None, profile: bool | None = None, adaptive: bool | None = None, samples: int | None = None, softness: float | None = None)

Denoise audio stream using Wavelets.

Parameters:

• sigma (float) – set noise sigma

• levels (int) – set number of wavelet levels

• wavet (str) – set wavelet type possible values: sym2, sym4, rbior68, deb10, sym10, coif5, bl3

• percent (float) – set percent of full denoising

• profile (bool) – profile noise

• adaptive (bool) – adaptive profiling of noise

• samples (int) – set frame size in number of samples

• softness (float) – set thresholding softness

zprp_ffmpeg.generated_filters.agate(graph: Stream)

Audio gate.

zprp_ffmpeg.generated_filters.agraphmonitor(graph: Stream)

Show various filtergraph stats.

zprp_ffmpeg.generated_filters.ahistogram(graph: Stream, dmode: str | None = None, rate: str | None = None, size: int | None = None, scale: str | None = None, ascale: str | None = None, acount: int | None = None, rheight: float | None = None, slide: str | None = None, hmode: str | None = None)

Convert input audio to histogram video output.

Parameters:

• dmode (str) – set method to display channels possible values: single, separate

• rate (str) – set video rate

• size (int) – set video size

• scale (str) – set display scale possible values: log, sqrt, cbrt, lin, rlog

• ascale (str) – set amplitude scale possible values: log, lin

• acount (int) – how much frames to accumulate

• rheight (float) – set histogram ratio of window height

• slide (str) – set sonogram sliding possible values: replace, scroll

• hmode (str) – set histograms mode possible values: abs, sign

zprp_ffmpeg.generated_filters.aintegral(graph: Stream)

Compute integral of input audio.

zprp_ffmpeg.generated_filters.ainterleave(graph: Stream, nb_inputs: int | None = None, duration: str | None = None)

Temporally interleave audio inputs.

Parameters:

• nb_inputs (int) – set number of inputs

• duration (str) – how to determine the end-of-stream possible values: longest, shortest, first

zprp_ffmpeg.generated_filters.alatency(graph: Stream)

Report audio filtering latency.

zprp_ffmpeg.generated_filters.alimiter(graph: Stream, level_in: float | None = None, level_out: float | None = None, limit: float | None = None, attack: float | None = None, release: float | None = None, asc: bool | None = None, asc_level: float | None = None, level: bool | None = None, latency: bool | None = None)

Audio lookahead limiter.

Parameters:

• level_in (float) – set input level

• level_out (float) – set output level

• limit (float) – set limit

• attack (float) – set attack

• release (float) – set release

• asc (bool) – enable asc

• asc_level (float) – set asc level

• level (bool) – auto level

• latency (bool) – compensate delay

zprp_ffmpeg.generated_filters.allpass(graph: Stream, frequency: float | None = None, width_type: str | None = None, width: float | None = None, mix: float | None = None, channels: str | None = None, normalize: bool | None = None, order: int | None = None, transform: str | None = None, precision: str | None = None)

Apply a two-pole all-pass filter.

Parameters:

• frequency (float) – set central frequency

• width_type (str) – set filter-width type possible values: h, q, o, s, k

• width (float) – set width

• mix (float) – set mix

• channels (str) – set channels to filter

• normalize (bool) – normalize coefficients

• order (int) – set filter order

• transform (str) – set transform type possible values: di, dii, tdi, tdii, latt, svf, zdf

• precision (str) – set filtering precision possible values: auto, s16, s32, f32, f64

zprp_ffmpeg.generated_filters.allrgb(graph: Stream)

Generate all RGB colors.

zprp_ffmpeg.generated_filters.allyuv(graph: Stream)

Generate all yuv colors.

zprp_ffmpeg.generated_filters.aloop(graph: Stream, loop: int | None = None, size: int | None = None, start: int | None = None, time: int | None = None)

Loop audio samples.

Parameters:

• loop (int) – number of loops

• size (int) – max number of samples to loop

• start (int) – set the loop start sample

• time (int) – set the loop start time

zprp_ffmpeg.generated_filters.alphamerge(graph: Stream)

Copy the luma value of the second input into the alpha channel of the first input.

zprp_ffmpeg.generated_filters.amerge(graph: Stream, inputs: int | None = None)

Merge two or more audio streams into a single multi-channel stream.

Parameters:

inputs (int) – specify the number of inputs

zprp_ffmpeg.generated_filters.ametadata(graph: Stream, mode: str | None = None, key: str | None = None, value: str | None = None, function: str | None = None, expr: str | None = None, file: str | None = None, direct: bool | None = None)

Manipulate audio frame metadata.

Parameters:

• mode (str) – set a mode of operation possible values: select, add, modify, delete, print

• key (str) – set metadata key

• value (str) – set metadata value

• function (str) – function for comparing values possible values: same_str, starts_with, less, equal, greater, expr, ends_with

• expr (str) – set expression for expr function

• file (str) – set file where to print metadata information

• direct (bool) – reduce buffering when printing to user-set file or pipe

zprp_ffmpeg.generated_filters.amix(graph: Stream, inputs: int | None = None, duration: str | None = None, dropout_transition: float | None = None, weights: str | None = None, normalize: bool | None = None)

Audio mixing.

Parameters:

• inputs (int) – Number of inputs.

• duration (str) – How to determine the end-of-stream. possible values: longest, shortest, first

• dropout_transition (float) – Transition time, in seconds, for volume renormalization when an input stream ends.

• weights (str) – Set weight for each input.

• normalize (bool) – Scale inputs

zprp_ffmpeg.generated_filters.amplify(graph: Stream, radius: int | None = None, factor: float | None = None, threshold: float | None = None, tolerance: float | None = None, low: float | None = None, high: float | None = None, planes: str | None = None)

Amplify changes between successive video frames.

Parameters:

• radius (int) – set radius

• factor (float) – set factor

• threshold (float) – set threshold

• tolerance (float) – set tolerance

• low (float) – set low limit for amplification

• high (float) – set high limit for amplification

• planes (str) – set what planes to filter

zprp_ffmpeg.generated_filters.amultiply(graph: Stream)

Multiply two audio streams.

zprp_ffmpeg.generated_filters.anlmdn(graph: Stream, strength: float | None = None, patch: int | None = None, research: int | None = None, output: str | None = None, smooth: float | None = None)

Reduce broadband noise from stream using Non-Local Means.

Parameters:

• strength (float) – set denoising strength

• patch (int) – set patch duration

• research (int) – set research duration

• output (str) – set output mode possible values: i, o, n

• smooth (float) – set smooth factor

zprp_ffmpeg.generated_filters.anlmf(graph: Stream)

Apply Normalized Least-Mean-Fourth algorithm to first audio stream.

zprp_ffmpeg.generated_filters.anlms(graph: Stream, order: int | None = None, mu: float | None = None, eps: float | None = None, leakage: float | None = None, out_mode: str | None = None, precision: str | None = None)

Apply Normalized Least-Mean-Squares algorithm to first audio stream.

Parameters:

• order (int) – set the filter order

• mu (float) – set the filter mu

• eps (float) – set the filter eps

• leakage (float) – set the filter leakage

• out_mode (str) – set output mode possible values: i, d, o, n, e

• precision (str) – set processing precision possible values: auto, float, double

zprp_ffmpeg.generated_filters.anoisesrc(graph: Stream, sample_rate: int | None = None, amplitude: float | None = None, duration: int | None = None, color: str | None = None, seed: int | None = None, nb_samples: int | None = None, density: float | None = None)

Generate a noise audio signal.

Parameters:

• sample_rate (int) – set sample rate

• amplitude (float) – set amplitude

• duration (int) – set duration

• color (str) – set noise color possible values: white, pink, brown, blue, violet, velvet

• seed (int) – set random seed

• nb_samples (int) – set the number of samples per requested frame

• density (float) – set density

zprp_ffmpeg.generated_filters.anull(graph: Stream)

Pass the source unchanged to the output.

zprp_ffmpeg.generated_filters.anullsrc(graph: Stream, channel_layout: str | None = None, sample_rate: int | None = None, nb_samples: int | None = None, duration: int | None = None)

Null audio source, return empty audio frames.

Parameters:

• channel_layout (str) – set channel_layout

• sample_rate (int) – set sample rate

• nb_samples (int) – set the number of samples per requested frame

• duration (int) – set the audio duration

zprp_ffmpeg.generated_filters.apad(graph: Stream, packet_size: int | None = None, pad_len: int | None = None, whole_len: int | None = None, pad_dur: int | None = None, whole_dur: int | None = None)

Pad audio with silence.

Parameters:

• packet_size (int) – set silence packet size

• pad_len (int) – set number of samples of silence to add

• whole_len (int) – set minimum target number of samples in the audio stream

• pad_dur (int) – set duration of silence to add

• whole_dur (int) – set minimum target duration in the audio stream

zprp_ffmpeg.generated_filters.aperms(graph: Stream)

Set permissions for the output audio frame.

zprp_ffmpeg.generated_filters.aphaser(graph: Stream, in_gain: float | None = None, out_gain: float | None = None, delay: float | None = None, decay: float | None = None, speed: float | None = None, type: str | None = None)

Add a phasing effect to the audio.

Parameters:

• in_gain (float) – set input gain

• out_gain (float) – set output gain

• delay (float) – set delay in milliseconds

• decay (float) – set decay

• speed (float) – set modulation speed

• type (str) – set modulation type possible values: triangular, t, sinusoidal, s

zprp_ffmpeg.generated_filters.aphaseshift(graph: Stream, shift: float | None = None, level: float | None = None, order: int | None = None)

Apply phase shifting to input audio.

Parameters:

• shift (float) – set phase shift

• level (float) – set output level

• order (int) – set filter order

zprp_ffmpeg.generated_filters.apsnr(graph: Stream)

Measure Audio Peak Signal-to-Noise Ratio.

zprp_ffmpeg.generated_filters.apsyclip(graph: Stream, level_in: float | None = None, level_out: float | None = None, clip: float | None = None, diff: bool | None = None, adaptive: float | None = None, iterations: int | None = None, level: bool | None = None)

Audio Psychoacoustic Clipper.

Parameters:

• level_in (float) – set input level

• level_out (float) – set output level

• clip (float) – set clip level

• diff (bool) – enable difference

• adaptive (float) – set adaptive distortion

• iterations (int) – set iterations

• level (bool) – set auto level

zprp_ffmpeg.generated_filters.apulsator(graph: Stream, level_in: float | None = None, level_out: float | None = None, mode: str | None = None, amount: float | None = None, offset_l: float | None = None, offset_r: float | None = None, width: float | None = None, timing: str | None = None, bpm: float | None = None, ms: int | None = None, hz: float | None = None)

Audio pulsator.

Parameters:

• level_in (float) – set input gain

• level_out (float) – set output gain

• mode (str) – set mode possible values: sine, triangle, square, sawup, sawdown

• amount (float) – set modulation

• offset_l (float) – set offset L

• offset_r (float) – set offset R

• width (float) – set pulse width

• timing (str) – set timing possible values: bpm, ms, hz

• bpm (float) – set BPM

• ms (int) – set ms

• hz (float) – set frequency

zprp_ffmpeg.generated_filters.arealtime(graph: Stream)

Slow down filtering to match realtime.

zprp_ffmpeg.generated_filters.aresample(graph: Stream)

Resample audio data.

zprp_ffmpeg.generated_filters.areverse(graph: Stream)

Reverse an audio clip.

zprp_ffmpeg.generated_filters.arls(graph: Stream, order: int | None = None, _lambda: float | None = None, delta: float | None = None, out_mode: str | None = None, precision: str | None = None)

Apply Recursive Least Squares algorithm to first audio stream.

Parameters:

• order (int) – set the filter order

• lambda (float) – set the filter lambda

• delta (float) – set the filter delta

• out_mode (str) – set output mode possible values: i, d, o, n, e

• precision (str) – set processing precision possible values: auto, float, double

zprp_ffmpeg.generated_filters.arnndn(graph: Stream, model: str | None = None, mix: float | None = None)

Reduce noise from speech using Recurrent Neural Networks.

Parameters:

• model (str) – set model name

• mix (float) – set output vs input mix

zprp_ffmpeg.generated_filters.asdr(graph: Stream)

Measure Audio Signal-to-Distortion Ratio.

zprp_ffmpeg.generated_filters.asendcmd(graph: Stream)

Send commands to filters.

zprp_ffmpeg.generated_filters.asetnsamples(graph: Stream, nb_out_samples: int | None = None, pad: bool | None = None)

Set the number of samples for each output audio frames.

Parameters:

• nb_out_samples (int) – set the number of per-frame output samples

• pad (bool) – pad last frame with zeros

zprp_ffmpeg.generated_filters.asetpts(graph: Stream, expr: str | None = None)

Set PTS for the output audio frame.

Parameters:

expr (str) – Expression determining the frame timestamp

zprp_ffmpeg.generated_filters.asetrate(graph: Stream, sample_rate: int | None = None)

Change the sample rate without altering the data.

Parameters:

sample_rate (int) – set the sample rate

zprp_ffmpeg.generated_filters.asettb(graph: Stream, expr: str | None = None)

Set timebase for the audio output link.

Parameters:

expr (str) – set expression determining the output timebase

zprp_ffmpeg.generated_filters.ashowinfo(graph: Stream)

Show textual information for each audio frame.

zprp_ffmpeg.generated_filters.asidedata(graph: Stream, mode: str | None = None, type: str | None = None)

Manipulate audio frame side data.

Parameters:

• mode (str) – set a mode of operation possible values: select, delete

• type (str) – set side data type possible values: PANSCAN, A53_CC, STEREO3D, MATRIXENCODING, DOWNMIX_INFO, REPLAYGAIN, DISPLAYMATRIX, AFD, MOTION_VECTORS, SKIP_SAMPLES, AUDIO_SERVICE_TYPE, MASTERING_DISPLAY_METADATA, GOP_TIMECODE, SPHERICAL, CONTENT_LIGHT_LEVEL, ICC_PROFILE, S12M_TIMECOD, DYNAMIC_HDR_PLUS, REGIONS_OF_INTEREST, VIDEO_ENC_PARAMS, SEI_UNREGISTERED, FILM_GRAIN_PARAMS, DETECTION_BOUNDING_BOXES, DETECTION_BBOXES, DOVI_RPU_BUFFER, DOVI_METADATA, DYNAMIC_HDR_VIVID, AMBIENT_VIEWING_ENVIRONMENT, VIDEO_HINT

zprp_ffmpeg.generated_filters.asisdr(graph: Stream)

Measure Audio Scale-Invariant Signal-to-Distortion Ratio.

zprp_ffmpeg.generated_filters.asoftclip(graph: Stream, type: str | None = None, threshold: float | None = None, output: float | None = None, param: float | None = None, oversample: int | None = None)

Audio Soft Clipper.

Parameters:

• type (str) – set softclip type possible values: hard, tanh, atan, cubic, exp, alg, quintic, sin, erf

• threshold (float) – set softclip threshold

• output (float) – set softclip output gain

• param (float) – set softclip parameter

• oversample (int) – set oversample factor

zprp_ffmpeg.generated_filters.aspectralstats(graph: Stream, win_size: int | None = None, win_func: str | None = None, overlap: float | None = None, measure: str | None = None)

Show frequency domain statistics about audio frames.

Parameters:

• win_size (int) – set the window size

• win_func (str) – set window function possible values: rect, bartlett, hann, hanning, hamming, blackman, welch, flattop, bharris, bnuttall, bhann, sine, nuttall, lanczos, gauss, tukey, dolph, cauchy, parzen, poisson, bohman, kaiser

• overlap (float) – set window overlap

• measure (str) – select the parameters which are measured possible values: none, all, mean, variance, centroid, spread, skewness, kurtosis, entropy, flatness, crest, flux, slope, decrease, rolloff

zprp_ffmpeg.generated_filters.astats(graph: Stream, length: float | None = None, metadata: bool | None = None, reset: int | None = None, measure_perchannel: str | None = None, measure_overall: str | None = None)

Show time domain statistics about audio frames.

Parameters:

• length (float) – set the window length

• metadata (bool) – inject metadata in the filtergraph

• reset (int) – Set the number of frames over which cumulative stats are calculated before being reset

• measure_perchannel (str) – Select the parameters which are measured per channel possible values: none, all, Bit_depth, Crest_factor, DC_offset, Dynamic_range, Entropy, Flat_factor, Max_difference, Max_level, Mean_difference, Min_difference, Min_level, Noise_floor, Noise_floor_count, Number_of_Infs, Number_of_NaNs, Number_of_denormals, Number_of_samples, Peak_count, Peak_level, RMS_difference, RMS_level, RMS_peak, RMS_trough, Zero_crossings, Zero_crossings_rate, Abs_Peak_count

• measure_overall (str) – Select the parameters which are measured overall

zprp_ffmpeg.generated_filters.asubboost(graph: Stream, dry: float | None = None, wet: float | None = None, boost: float | None = None, decay: float | None = None, feedback: float | None = None, cutoff: float | None = None, slope: float | None = None, delay: float | None = None, channels: str | None = None)

Boost subwoofer frequencies.

Parameters:

• dry (float) – set dry gain

• wet (float) – set wet gain

• boost (float) – set max boost

• decay (float) – set decay

• feedback (float) – set feedback

• cutoff (float) – set cutoff

• slope (float) – set slope

• delay (float) – set delay

• channels (str) – set channels to filter

zprp_ffmpeg.generated_filters.asubcut(graph: Stream, cutoff: float | None = None, order: int | None = None, level: float | None = None)

Cut subwoofer frequencies.

Parameters:

• cutoff (float) – set cutoff frequency

• order (int) – set filter order

• level (float) – set input level

zprp_ffmpeg.generated_filters.asupercut(graph: Stream, cutoff: float | None = None, order: int | None = None, level: float | None = None)

Cut super frequencies.

Parameters:

• cutoff (float) – set cutoff frequency

• order (int) – set filter order

• level (float) – set input level

zprp_ffmpeg.generated_filters.asuperpass(graph: Stream)

Apply high order Butterworth band-pass filter.

zprp_ffmpeg.generated_filters.asuperstop(graph: Stream)

Apply high order Butterworth band-stop filter.

zprp_ffmpeg.generated_filters.atadenoise(graph: Stream, _0a: float | None = None, _0b: float | None = None, _1a: float | None = None, _1b: float | None = None, _2a: float | None = None, _2b: float | None = None, s: int | None = None, p: str | None = None, a: str | None = None, _0s: float | None = None, _1s: float | None = None, _2s: float | None = None)

Apply an Adaptive Temporal Averaging Denoiser.

Parameters:

• 0a (float) – set threshold A for 1st plane

• 0b (float) – set threshold B for 1st plane

• 1a (float) – set threshold A for 2nd plane

• 1b (float) – set threshold B for 2nd plane

• 2a (float) – set threshold A for 3rd plane

• 2b (float) – set threshold B for 3rd plane

• s (int) – set how many frames to use

• p (str) – set what planes to filter

• a (str) – set variant of algorithm possible values: p, s

• 0s (float) – set sigma for 1st plane

• 1s (float) – set sigma for 2nd plane

• 2s (float) – set sigma for 3rd plane

zprp_ffmpeg.generated_filters.atempo(graph: Stream, tempo: float | None = None)

Adjust audio tempo.

Parameters:

tempo (float) – set tempo scale factor

zprp_ffmpeg.generated_filters.atilt(graph: Stream, freq: float | None = None, slope: float | None = None, width: float | None = None, order: int | None = None, level: float | None = None)

Apply spectral tilt to audio.

Parameters:

• freq (float) – set central frequency

• slope (float) – set filter slope

• width (float) – set filter width

• order (int) – set filter order

• level (float) – set input level

zprp_ffmpeg.generated_filters.atrim(graph: Stream, start: int | None = None, end: int | None = None, start_pts: int | None = None, end_pts: int | None = None, duration: int | None = None, start_sample: int | None = None, end_sample: int | None = None)

Pick one continuous section from the input, drop the rest.

Parameters:

• start (int) – Timestamp of the first frame that should be passed

• end (int) – Timestamp of the first frame that should be dropped again

• start_pts (int) – Timestamp of the first frame that should be passed

• end_pts (int) – Timestamp of the first frame that should be dropped again

• duration (int) – Maximum duration of the output

• start_sample (int) – Number of the first audio sample that should be passed to the output

• end_sample (int) – Number of the first audio sample that should be dropped again

zprp_ffmpeg.generated_filters.avectorscope(graph: Stream, mode: str | None = None, rate: str | None = None, size: int | None = None, rc: int | None = None, gc: int | None = None, bc: int | None = None, ac: int | None = None, rf: int | None = None, gf: int | None = None, bf: int | None = None, af: int | None = None, zoom: float | None = None, draw: str | None = None, scale: str | None = None, swap: bool | None = None, mirror: str | None = None)

Convert input audio to vectorscope video output.

Parameters:

• mode (str) – set mode possible values: lissajous, lissajous_xy, polar

• rate (str) – set video rate

• size (int) – set video size

• rc (int) – set red contrast

• gc (int) – set green contrast

• bc (int) – set blue contrast

• ac (int) – set alpha contrast

• rf (int) – set red fade

• gf (int) – set green fade

• bf (int) – set blue fade

• af (int) – set alpha fade

• zoom (float) – set zoom factor

• draw (str) – set draw mode possible values: dot, line, aaline

• scale (str) – set amplitude scale mode possible values: lin, sqrt, cbrt, log

• swap (bool) – swap x axis with y axis

• mirror (str) – mirror axis possible values: none, x, y, xy

zprp_ffmpeg.generated_filters.avgblur(graph: Stream, sizeX: int | None = None, planes: int | None = None, sizeY: int | None = None)

Apply Average Blur filter.

Parameters:

• sizeX (int) – set horizontal size

• planes (int) – set planes to filter

• sizeY (int) – set vertical size

zprp_ffmpeg.generated_filters.avgblur_vulkan(graph: Stream, sizeX: int | None = None, sizeY: int | None = None, planes: int | None = None)

Apply avgblur mask to input video

Parameters:

• sizeX (int) – Set horizontal radius

• sizeY (int) – Set vertical radius

• planes (int) – Set planes to filter (bitmask)

zprp_ffmpeg.generated_filters.avsynctest(graph: Stream, size: int | None = None, framerate: str | None = None, samplerate: int | None = None, amplitude: float | None = None, period: int | None = None, delay: int | None = None, cycle: bool | None = None, duration: int | None = None, fg: str | None = None, bg: str | None = None, ag: str | None = None)

Generate an Audio Video Sync Test.

Parameters:

• size (int) – set frame size

• framerate (str) – set frame rate

• samplerate (int) – set sample rate

• amplitude (float) – set beep amplitude

• period (int) – set beep period

• delay (int) – set flash delay

• cycle (bool) – set delay cycle

• duration (int) – set duration

• fg (str) – set foreground color

• bg (str) – set background color

• ag (str) – set additional color

zprp_ffmpeg.generated_filters.axcorrelate(graph: Stream, size: int | None = None, algo: str | None = None)

Cross-correlate two audio streams.

Parameters:

• size (int) – set the segment size

• algo (str) – set the algorithm possible values: slow, fast, best

zprp_ffmpeg.generated_filters.backgroundkey(graph: Stream, threshold: float | None = None, similarity: float | None = None, blend: float | None = None)

Turns a static background into transparency.

Parameters:

• threshold (float) – set the scene change threshold

• similarity (float) – set the similarity

• blend (float) – set the blend value

zprp_ffmpeg.generated_filters.bandpass(graph: Stream, frequency: float | None = None, width_type: str | None = None, width: float | None = None, csg: bool | None = None, mix: float | None = None, channels: str | None = None, normalize: bool | None = None, transform: str | None = None, precision: str | None = None, blocksize: int | None = None)

Apply a two-pole Butterworth band-pass filter.

Parameters:

• frequency (float) – set central frequency

• width_type (str) – set filter-width type possible values: h, q, o, s, k

• width (float) – set width

• csg (bool) – use constant skirt gain

• mix (float) – set mix

• channels (str) – set channels to filter

• normalize (bool) – normalize coefficients

• transform (str) – set transform type possible values: di, dii, tdi, tdii, latt, svf, zdf

• precision (str) – set filtering precision possible values: auto, s16, s32, f32, f64

• blocksize (int) – set the block size

zprp_ffmpeg.generated_filters.bandreject(graph: Stream, frequency: float | None = None, width_type: str | None = None, width: float | None = None, mix: float | None = None, channels: str | None = None, normalize: bool | None = None, transform: str | None = None, precision: str | None = None, blocksize: int | None = None)

Apply a two-pole Butterworth band-reject filter.

Parameters:

• frequency (float) – set central frequency

• width_type (str) – set filter-width type possible values: h, q, o, s, k

• width (float) – set width

• mix (float) – set mix

• channels (str) – set channels to filter

• normalize (bool) – normalize coefficients

• transform (str) – set transform type possible values: di, dii, tdi, tdii, latt, svf, zdf

• precision (str) – set filtering precision possible values: auto, s16, s32, f32, f64

• blocksize (int) – set the block size

zprp_ffmpeg.generated_filters.bass(graph: Stream)

Boost or cut lower frequencies.

zprp_ffmpeg.generated_filters.bbox(graph: Stream, min_val: int | None = None)

Compute bounding box for each frame.

Parameters:

min_val (int) – set minimum luminance value for bounding box

zprp_ffmpeg.generated_filters.bench(graph: Stream, action: str | None = None)

Benchmark part of a filtergraph.

Parameters:

action (str) – set action possible values: start, stop

zprp_ffmpeg.generated_filters.bilateral(graph: Stream, sigmaS: float | None = None, sigmaR: float | None = None, planes: int | None = None)

Apply Bilateral filter.

Parameters:

• sigmaS (float) – set spatial sigma

• sigmaR (float) – set range sigma

• planes (int) – set planes to filter

zprp_ffmpeg.generated_filters.biquad(graph: Stream, a0: float | None = None, a1: float | None = None, a2: float | None = None, b0: float | None = None, b1: float | None = None, b2: float | None = None, mix: float | None = None, channels: str | None = None, normalize: bool | None = None, transform: str | None = None, precision: str | None = None, blocksize: int | None = None)

Apply a biquad IIR filter with the given coefficients.

Parameters:

• mix (float) – set mix

• channels (str) – set channels to filter

• normalize (bool) – normalize coefficients

• transform (str) – set transform type possible values: di, dii, tdi, tdii, latt, svf, zdf

• precision (str) – set filtering precision possible values: auto, s16, s32, f32, f64

• blocksize (int) – set the block size

zprp_ffmpeg.generated_filters.bitplanenoise(graph: Stream, bitplane: int | None = None, filter: bool | None = None)

Measure bit plane noise.

Parameters:

• bitplane (int) – set bit plane to use for measuring noise

• filter (bool) – show noisy pixels

zprp_ffmpeg.generated_filters.blackdetect(graph: Stream, d: float | None = None, picture_black_ratio_th: float | None = None, pixel_black_th: float | None = None)

Detect video intervals that are (almost) black.

Parameters:

• d (float) – set minimum detected black duration in seconds

• picture_black_ratio_th (float) – set the picture black ratio threshold

• pixel_black_th (float) – set the pixel black threshold

zprp_ffmpeg.generated_filters.blackframe(graph: Stream, amount: int | None = None, threshold: int | None = None)

Detect frames that are (almost) black.

Parameters:

• amount (int) – percentage of the pixels that have to be below the threshold for the frame to be considered black

• threshold (int) – threshold below which a pixel value is considered black

zprp_ffmpeg.generated_filters.blend(graph: Stream, c0_mode: str | None = None, c1_mode: str | None = None, c2_mode: str | None = None, c3_mode: str | None = None, all_mode: str | None = None, c0_expr: str | None = None, c1_expr: str | None = None, c2_expr: str | None = None, c3_expr: str | None = None, all_expr: str | None = None, c0_opacity: float | None = None, c1_opacity: float | None = None, c2_opacity: float | None = None, c3_opacity: float | None = None, all_opacity: float | None = None)

Blend two video frames into each other.

Parameters:

• c0_mode (str) – set component #0 blend mode possible values: addition, addition128, grainmerge, and, average, burn, darken, difference, difference128, grainextract, divide, dodge, exclusion, extremity, freeze, glow, hardlight, hardmix, heat, lighten, linearlight, multiply, multiply128, negation, normal, or, overlay, phoenix, pinlight, reflect, screen, softlight, subtract, vividlight, xor, softdifference, geometric, harmonic, bleach, stain, interpolate, hardoverlay

• c1_mode (str) – set component #1 blend mode possible values: addition, addition128, grainmerge, and, average, burn, darken, difference, difference128, grainextract, divide, dodge, exclusion, extremity, freeze, glow, hardlight, hardmix, heat, lighten, linearlight, multiply, multiply128, negation, normal, or, overlay, phoenix, pinlight, reflect, screen, softlight, subtract, vividlight, xor, softdifference, geometric, harmonic, bleach, stain, interpolate, hardoverlay

• c2_mode (str) – set component #2 blend mode possible values: addition, addition128, grainmerge, and, average, burn, darken, difference, difference128, grainextract, divide, dodge, exclusion, extremity, freeze, glow, hardlight, hardmix, heat, lighten, linearlight, multiply, multiply128, negation, normal, or, overlay, phoenix, pinlight, reflect, screen, softlight, subtract, vividlight, xor, softdifference, geometric, harmonic, bleach, stain, interpolate, hardoverlay

• c3_mode (str) – set component #3 blend mode possible values: addition, addition128, grainmerge, and, average, burn, darken, difference, difference128, grainextract, divide, dodge, exclusion, extremity, freeze, glow, hardlight, hardmix, heat, lighten, linearlight, multiply, multiply128, negation, normal, or, overlay, phoenix, pinlight, reflect, screen, softlight, subtract, vividlight, xor, softdifference, geometric, harmonic, bleach, stain, interpolate, hardoverlay

• all_mode (str) – set blend mode for all components possible values: addition, addition128, grainmerge, and, average, burn, darken, difference, difference128, grainextract, divide, dodge, exclusion, extremity, freeze, glow, hardlight, hardmix, heat, lighten, linearlight, multiply, multiply128, negation, normal, or, overlay, phoenix, pinlight, reflect, screen, softlight, subtract, vividlight, xor, softdifference, geometric, harmonic, bleach, stain, interpolate, hardoverlay

• c0_expr (str) – set color component #0 expression

• c1_expr (str) – set color component #1 expression

• c2_expr (str) – set color component #2 expression

• c3_expr (str) – set color component #3 expression

• all_expr (str) – set expression for all color components

• c0_opacity (float) – set color component #0 opacity

• c1_opacity (float) – set color component #1 opacity

• c2_opacity (float) – set color component #2 opacity

• c3_opacity (float) – set color component #3 opacity

• all_opacity (float) – set opacity for all color components

zprp_ffmpeg.generated_filters.blend_vulkan(graph: Stream, c0_mode: str | None = None, c1_mode: str | None = None, c2_mode: str | None = None, c3_mode: str | None = None, all_mode: str | None = None, c0_opacity: float | None = None, c1_opacity: float | None = None, c2_opacity: float | None = None, c3_opacity: float | None = None, all_opacity: float | None = None)

Blend two video frames in Vulkan

Parameters:

• c0_mode (str) – set component #0 blend mode possible values: normal, multiply

• c1_mode (str) – set component #1 blend mode possible values: normal, multiply

• c2_mode (str) – set component #2 blend mode possible values: normal, multiply

• c3_mode (str) – set component #3 blend mode possible values: normal, multiply

• all_mode (str) – set blend mode for all components possible values: normal, multiply

• c0_opacity (float) – set color component #0 opacity

• c1_opacity (float) – set color component #1 opacity

• c2_opacity (float) – set color component #2 opacity

• c3_opacity (float) – set color component #3 opacity

• all_opacity (float) – set opacity for all color components

zprp_ffmpeg.generated_filters.blockdetect(graph: Stream, period_min: int | None = None, period_max: int | None = None, planes: int | None = None)

Blockdetect filter.

Parameters:

• period_min (int) – Minimum period to search for

• period_max (int) – Maximum period to search for

• planes (int) – set planes to filter

zprp_ffmpeg.generated_filters.blurdetect(graph: Stream, high: float | None = None, low: float | None = None, radius: int | None = None, block_pct: int | None = None, block_width: int | None = None, block_height: int | None = None, planes: int | None = None)

Blurdetect filter.

Parameters:

• high (float) – set high threshold

• low (float) – set low threshold

• radius (int) – search radius for maxima detection

• block_pct (int) – block pooling threshold when calculating blurriness

• block_width (int) – block size for block-based abbreviation of blurriness

• block_height (int) – block size for block-based abbreviation of blurriness

• planes (int) – set planes to filter

zprp_ffmpeg.generated_filters.bm3d(graph: Stream, sigma: float | None = None, block: int | None = None, bstep: int | None = None, group: int | None = None, range: int | None = None, mstep: int | None = None, thmse: float | None = None, hdthr: float | None = None, estim: str | None = None, ref: bool | None = None, planes: int | None = None)

Block-Matching 3D denoiser.

Parameters:

• sigma (float) – set denoising strength

• block (int) – set size of local patch

• bstep (int) – set sliding step for processing blocks

• group (int) – set maximal number of similar blocks

• range (int) – set block matching range

• mstep (int) – set step for block matching

• thmse (float) – set threshold of mean square error for block matching

• hdthr (float) – set hard threshold for 3D transfer domain

• estim (str) – set filtering estimation mode possible values: basic, final

• ref (bool) – have reference stream

• planes (int) – set planes to filter

zprp_ffmpeg.generated_filters.boxblur(graph: Stream, luma_radius: str | None = None, lr: str | None = None, luma_power: int | None = None, lp: int | None = None, chroma_radius: str | None = None, cr: str | None = None, chroma_power: int | None = None, cp: int | None = None, alpha_radius: str | None = None, ar: str | None = None, alpha_power: int | None = None, ap: int | None = None)

Blur the input.

Parameters:

• luma_radius (str) – Radius of the luma blurring box

• lr (str) – Radius of the luma blurring box

• luma_power (int) – How many times should the boxblur be applied to luma

• lp (int) – How many times should the boxblur be applied to luma

• chroma_radius (str) – Radius of the chroma blurring box

• cr (str) – Radius of the chroma blurring box

• chroma_power (int) – How many times should the boxblur be applied to chroma

• cp (int) – How many times should the boxblur be applied to chroma

• alpha_radius (str) – Radius of the alpha blurring box

• ar (str) – Radius of the alpha blurring box

• alpha_power (int) – How many times should the boxblur be applied to alpha

• ap (int) – How many times should the boxblur be applied to alpha

zprp_ffmpeg.generated_filters.buffer(graph: Stream, width: int | None = None, height: int | None = None, pix_fmt: str | None = None, sar: int | None = None, time_base: int | None = None, frame_rate: int | None = None, colorspace: str | None = None, range: str | None = None)

Buffer video frames, and make them accessible to the filterchain.

Parameters:

• sar (int) – sample aspect ratio

• colorspace (str) – select colorspace possible values: gbr, bt709, unknown, fcc, bt470bg, smpte170m, smpte240m, ycgco, ycgco-re, ycgco-ro, bt2020nc, bt2020c, smpte2085, chroma-derived-nc, chroma-derived-c, ictcp, ipt-c2

• range (str) – select color range possible values: unspecified, unknown, limited, tv, mpeg, full, pc, jpeg

zprp_ffmpeg.generated_filters.bwdif(graph: Stream, mode: str | None = None, parity: str | None = None, deint: str | None = None)

Deinterlace the input image.

Parameters:

• mode (str) – specify the interlacing mode possible values: send_frame, send_field

• parity (str) – specify the assumed picture field parity possible values: tff, bff, auto

• deint (str) – specify which frames to deinterlace possible values: all, interlaced

zprp_ffmpeg.generated_filters.bwdif_vulkan(graph: Stream)

Deinterlace Vulkan frames via bwdif

zprp_ffmpeg.generated_filters.cas(graph: Stream, strength: float | None = None, planes: str | None = None)

Contrast Adaptive Sharpen.

Parameters:

• strength (float) – set the sharpening strength

• planes (str) – set what planes to filter

zprp_ffmpeg.generated_filters.ccrepack(graph: Stream)

Repack CEA-708 closed caption metadata

zprp_ffmpeg.generated_filters.cellauto(graph: Stream, filename: str | None = None, pattern: str | None = None, rate: str | None = None, size: int | None = None, rule: int | None = None, random_fill_ratio: float | None = None, random_seed: int | None = None, scroll: bool | None = None, start_full: bool | None = None, stitch: bool | None = None)

Create pattern generated by an elementary cellular automaton.

Parameters:

• filename (str) – read initial pattern from file

• pattern (str) – set initial pattern

• rate (str) – set video rate

• size (int) – set video size

• rule (int) – set rule

• random_fill_ratio (float) – set fill ratio for filling initial grid randomly

• random_seed (int) – set the seed for filling the initial grid randomly

• scroll (bool) – scroll pattern downward

• start_full (bool) – start filling the whole video

• stitch (bool) – stitch boundaries

zprp_ffmpeg.generated_filters.channelmap(graph: Stream, map: str | None = None, channel_layout: str | None = None)

Remap audio channels.

Parameters:

• map (str) – A comma-separated list of input channel numbers in output order.

• channel_layout (str) – Output channel layout.

zprp_ffmpeg.generated_filters.chorus(graph: Stream, in_gain: float | None = None, out_gain: float | None = None, delays: str | None = None, decays: str | None = None, speeds: str | None = None, depths: str | None = None)

Add a chorus effect to the audio.

Parameters:

• in_gain (float) – set input gain

• out_gain (float) – set output gain

• delays (str) – set delays

• decays (str) – set decays

• speeds (str) – set speeds

• depths (str) – set depths

zprp_ffmpeg.generated_filters.chromaber_vulkan(graph: Stream, dist_x: float | None = None, dist_y: float | None = None)

Offset chroma of input video (chromatic aberration)

Parameters:

• dist_x (float) – Set horizontal distortion amount

• dist_y (float) – Set vertical distortion amount

zprp_ffmpeg.generated_filters.chromahold(graph: Stream, color: str | None = None, similarity: float | None = None, blend: float | None = None, yuv: bool | None = None)

Turns a certain color range into gray.

Parameters:

• color (str) – set the chromahold key color

• similarity (float) – set the chromahold similarity value

• blend (float) – set the chromahold blend value

• yuv (bool) – color parameter is in yuv instead of rgb

zprp_ffmpeg.generated_filters.chromakey(graph: Stream, color: str | None = None, similarity: float | None = None, blend: float | None = None, yuv: bool | None = None)

Turns a certain color into transparency. Operates on YUV colors.

Parameters:

• color (str) – set the chromakey key color

• similarity (float) – set the chromakey similarity value

• blend (float) – set the chromakey key blend value

• yuv (bool) – color parameter is in yuv instead of rgb

zprp_ffmpeg.generated_filters.chromanr(graph: Stream, thres: float | None = None, sizew: int | None = None, sizeh: int | None = None, stepw: int | None = None, steph: int | None = None, threy: float | None = None, threu: float | None = None, threv: float | None = None, distance: str | None = None)

Reduce chrominance noise.

Parameters:

• thres (float) – set y+u+v threshold

• sizew (int) – set horizontal patch size

• sizeh (int) – set vertical patch size

• stepw (int) – set horizontal step

• steph (int) – set vertical step

• threy (float) – set y threshold

• threu (float) – set u threshold

• threv (float) – set v threshold

• distance (str) – set distance type possible values: manhattan, euclidean

zprp_ffmpeg.generated_filters.chromashift(graph: Stream, cbh: int | None = None, cbv: int | None = None, crh: int | None = None, crv: int | None = None, edge: str | None = None)

Shift chroma.

Parameters:

• cbh (int) – shift chroma-blue horizontally

• cbv (int) – shift chroma-blue vertically

• crh (int) – shift chroma-red horizontally

• crv (int) – shift chroma-red vertically

• edge (str) – set edge operation possible values: smear, wrap

zprp_ffmpeg.generated_filters.ciescope(graph: Stream, system: str | None = None, cie: str | None = None, gamuts: str | None = None, size: int | None = None, intensity: float | None = None, contrast: float | None = None, corrgamma: bool | None = None, showwhite: bool | None = None, gamma: float | None = None, fill: bool | None = None)

Video CIE scope.

Parameters:

• system (str) – set color system possible values: ntsc, 470m, ebu, 470bg, smpte, 240m, apple, widergb, cie1931, hdtv, rec709, uhdtv, rec2020, dcip3

• cie (str) – set cie system possible values: xyy, ucs, luv

• gamuts (str) – set what gamuts to draw possible values: ntsc, 470m, ebu, 470bg, smpte, 240m, apple, widergb, cie1931, hdtv, rec709, uhdtv, rec2020, dcip3

• size (int) – set ciescope size

• intensity (float) – set ciescope intensity

• fill (bool) – fill with CIE colors

zprp_ffmpeg.generated_filters.codecview(graph: Stream, mv: str | None = None, qp: bool | None = None, mv_type: str | None = None, frame_type: str | None = None, block: bool | None = None)

Visualize information about some codecs.

Parameters:

• mv (str) – set motion vectors to visualize possible values: pf, bf, bb

• mv_type (str) – set motion vectors type possible values: fp, bp

• frame_type (str) – set frame types to visualize motion vectors of possible values: if, pf, bf

• block (bool) – set block partitioning structure to visualize

zprp_ffmpeg.generated_filters.color(graph: Stream, color: str | None = None, size: int | None = None, rate: str | None = None, duration: int | None = None, sar: int | None = None)

Provide an uniformly colored input.

Parameters:

• color (str) – set color

• size (int) – set video size

• rate (str) – set video rate

• duration (int) – set video duration

• sar (int) – set video sample aspect ratio

zprp_ffmpeg.generated_filters.color_vulkan(graph: Stream, color: str | None = None, size: int | None = None, rate: str | None = None, duration: int | None = None, sar: int | None = None, format: str | None = None, out_range: str | None = None)

Generate a constant color (Vulkan)

Parameters:

• color (str) – set color

• size (int) – set video size

• rate (str) – set video rate

• duration (int) – set video duration

• sar (int) – set video sample aspect ratio

• format (str) – Output video format (software format of hardware frames)

• out_range (str) – Output colour range (from 0 to 2) (default 0) possible values: full, limited, jpeg, mpeg, tv, pc

zprp_ffmpeg.generated_filters.colorbalance(graph: Stream, rs: float | None = None, gs: float | None = None, bs: float | None = None, rm: float | None = None, gm: float | None = None, bm: float | None = None, rh: float | None = None, gh: float | None = None, bh: float | None = None, pl: bool | None = None)

Adjust the color balance.

Parameters:

• rs (float) – set red shadows

• gs (float) – set green shadows

• bs (float) – set blue shadows

• rm (float) – set red midtones

• gm (float) – set green midtones

• bm (float) – set blue midtones

• rh (float) – set red highlights

• gh (float) – set green highlights

• bh (float) – set blue highlights

• pl (bool) – preserve lightness

zprp_ffmpeg.generated_filters.colorchannelmixer(graph: Stream, rr: float | None = None, rg: float | None = None, rb: float | None = None, ra: float | None = None, gr: float | None = None, gg: float | None = None, gb: float | None = None, ga: float | None = None, br: float | None = None, bg: float | None = None, bb: float | None = None, ba: float | None = None, ar: float | None = None, ag: float | None = None, ab: float | None = None, aa: float | None = None, pc: str | None = None, pa: float | None = None)

Adjust colors by mixing color channels.

Parameters:

• rr (float) – set the red gain for the red channel

• rg (float) – set the green gain for the red channel

• rb (float) – set the blue gain for the red channel

• ra (float) – set the alpha gain for the red channel

• gr (float) – set the red gain for the green channel

• gg (float) – set the green gain for the green channel

• gb (float) – set the blue gain for the green channel

• ga (float) – set the alpha gain for the green channel

• br (float) – set the red gain for the blue channel

• bg (float) – set the green gain for the blue channel

• bb (float) – set the blue gain for the blue channel

• ba (float) – set the alpha gain for the blue channel

• ar (float) – set the red gain for the alpha channel

• ag (float) – set the green gain for the alpha channel

• ab (float) – set the blue gain for the alpha channel

• aa (float) – set the alpha gain for the alpha channel

• pc (str) – set the preserve color mode possible values: none, lum, max, avg, sum, nrm, pwr

• pa (float) – set the preserve color amount

zprp_ffmpeg.generated_filters.colorchart(graph: Stream, rate: str | None = None, duration: int | None = None, sar: int | None = None, patch_size: int | None = None, preset: str | None = None)

Generate color checker chart.

Parameters:

• rate (str) – set video rate

• duration (int) – set video duration

• sar (int) – set video sample aspect ratio

• patch_size (int) – set the single patch size

• preset (str) – set the color checker chart preset possible values: reference, skintones

zprp_ffmpeg.generated_filters.colorcontrast(graph: Stream, rc: float | None = None, gm: float | None = None, by: float | None = None, rcw: float | None = None, gmw: float | None = None, byw: float | None = None, pl: float | None = None)

Adjust color contrast between RGB components.

Parameters:

• rc (float) – set the red-cyan contrast

• gm (float) – set the green-magenta contrast

• by (float) – set the blue-yellow contrast

• rcw (float) – set the red-cyan weight

• gmw (float) – set the green-magenta weight

• byw (float) – set the blue-yellow weight

• pl (float) – set the amount of preserving lightness

zprp_ffmpeg.generated_filters.colorcorrect(graph: Stream, rl: float | None = None, bl: float | None = None, rh: float | None = None, bh: float | None = None, saturation: float | None = None, analyze: str | None = None)

Adjust color white balance selectively for blacks and whites.

Parameters:

• rl (float) – set the red shadow spot

• bl (float) – set the blue shadow spot

• rh (float) – set the red highlight spot

• bh (float) – set the blue highlight spot

• saturation (float) – set the amount of saturation

• analyze (str) – set the analyze mode possible values: manual, average, minmax, median

zprp_ffmpeg.generated_filters.colorhold(graph: Stream, color: str | None = None, similarity: float | None = None, blend: float | None = None)

Turns a certain color range into gray. Operates on RGB colors.

Parameters:

• color (str) – set the colorhold key color

• similarity (float) – set the colorhold similarity value

• blend (float) – set the colorhold blend value

zprp_ffmpeg.generated_filters.colorize(graph: Stream, hue: float | None = None, saturation: float | None = None, lightness: float | None = None, mix: float | None = None)

Overlay a solid color on the video stream.

Parameters:

• hue (float) – set the hue

• saturation (float) – set the saturation

• lightness (float) – set the lightness

• mix (float) – set the mix of source lightness

zprp_ffmpeg.generated_filters.colorkey(graph: Stream, color: str | None = None, similarity: float | None = None, blend: float | None = None)

Turns a certain color into transparency. Operates on RGB colors.

Parameters:

• color (str) – set the colorkey key color

• similarity (float) – set the colorkey similarity value

• blend (float) – set the colorkey key blend value

zprp_ffmpeg.generated_filters.colorkey_opencl(graph: Stream, color: str | None = None, similarity: float | None = None, blend: float | None = None)

Turns a certain color into transparency. Operates on RGB colors.

Parameters:

• color (str) – set the colorkey key color

• similarity (float) – set the colorkey similarity value

• blend (float) – set the colorkey key blend value

zprp_ffmpeg.generated_filters.colorlevels(graph: Stream, rimin: float | None = None, gimin: float | None = None, bimin: float | None = None, aimin: float | None = None, rimax: float | None = None, gimax: float | None = None, bimax: float | None = None, aimax: float | None = None, romin: float | None = None, gomin: float | None = None, bomin: float | None = None, aomin: float | None = None, romax: float | None = None, gomax: float | None = None, bomax: float | None = None, aomax: float | None = None, preserve: str | None = None)

Adjust the color levels.

Parameters:

• rimin (float) – set input red black point

• gimin (float) – set input green black point

• bimin (float) – set input blue black point

• aimin (float) – set input alpha black point

• rimax (float) – set input red white point

• gimax (float) – set input green white point

• bimax (float) – set input blue white point

• aimax (float) – set input alpha white point

• romin (float) – set output red black point

• gomin (float) – set output green black point

• bomin (float) – set output blue black point

• aomin (float) – set output alpha black point

• romax (float) – set output red white point

• gomax (float) – set output green white point

• bomax (float) – set output blue white point

• aomax (float) – set output alpha white point

• preserve (str) – set preserve color mode possible values: none, lum, max, avg, sum, nrm, pwr

zprp_ffmpeg.generated_filters.colormap(graph: Stream, patch_size: int | None = None, nb_patches: int | None = None, type: str | None = None, kernel: str | None = None)

Apply custom Color Maps to video stream.

Parameters:

• patch_size (int) – set patch size

• nb_patches (int) – set number of patches

• type (str) – set the target type used possible values: relative, absolute

• kernel (str) – set the kernel used for measuring color difference possible values: euclidean, weuclidean

zprp_ffmpeg.generated_filters.colormatrix(graph: Stream, src: str | None = None, dst: str | None = None)

Convert color matrix.

Parameters:

• src (str) – set source color matrix possible values: bt709, fcc, bt601, bt470, bt470bg, smpte170m, smpte240m, bt2020

• dst (str) – set destination color matrix possible values: bt709, fcc, bt601, bt470, bt470bg, smpte170m, smpte240m, bt2020

zprp_ffmpeg.generated_filters.colorspace(graph: Stream, all: str | None = None, space: str | None = None, range: str | None = None, primaries: str | None = None, trc: str | None = None, format: str | None = None, fast: bool | None = None, dither: str | None = None, wpadapt: str | None = None, iall: int | None = None, ispace: int | None = None, irange: int | None = None, iprimaries: int | None = None, itrc: int | None = None)

Convert between colorspaces.

Parameters:

• all (str) – Set all color properties together possible values: bt470m, bt470bg, bt601-6-525, bt601-6-625, bt709, smpte170m, smpte240m, bt2020

• space (str) – Output colorspace possible values: bt709, fcc, bt470bg, smpte170m, smpte240m, ycgco, gbr, bt2020nc, bt2020ncl

• range (str) – Output color range possible values: tv, mpeg, pc, jpeg

• primaries (str) – Output color primaries possible values: bt709, bt470m, bt470bg, smpte170m, smpte240m, smpte428, film, smpte431, smpte432, bt2020, jedec-p22, ebu3213

• trc (str) – Output transfer characteristics possible values: bt709, bt470m, gamma22, bt470bg, gamma28, smpte170m, smpte240m, linear, srgb, iec61966-2-1, xvycc, iec61966-2-4, bt2020-10, bt2020-12

• format (str) – Output pixel format possible values: yuv420p, yuv420p10, yuv420p12, yuv422p, yuv422p10, yuv422p12, yuv444p, yuv444p10, yuv444p12

• fast (bool) – Ignore primary chromaticity and gamma correction

• dither (str) – Dithering mode possible values: none, fsb

• wpadapt (str) – Whitepoint adaptation method possible values: bradford, vonkries, identity

• iall (int) – Set all input color properties together

• ispace (int) – Input colorspace

• irange (int) – Input color range

• iprimaries (int) – Input color primaries

• itrc (int) – Input transfer characteristics

zprp_ffmpeg.generated_filters.colorspectrum(graph: Stream, size: int | None = None, rate: str | None = None, duration: int | None = None, sar: int | None = None, type: str | None = None)

Generate colors spectrum.

Parameters:

• size (int) – set video size

• rate (str) – set video rate

• duration (int) – set video duration

• sar (int) – set video sample aspect ratio

• type (str) – set the color spectrum type possible values: black, white, all

zprp_ffmpeg.generated_filters.colortemperature(graph: Stream, temperature: float | None = None, mix: float | None = None, pl: float | None = None)

Adjust color temperature of video.

Parameters:

• temperature (float) – set the temperature in Kelvin

• mix (float) – set the mix with filtered output

• pl (float) – set the amount of preserving lightness

zprp_ffmpeg.generated_filters.compand(graph: Stream, attacks: str | None = None, decays: str | None = None, points: str | None = None, soft_knee: float | None = None, gain: float | None = None, volume: float | None = None, delay: float | None = None)

Compress or expand audio dynamic range.

Parameters:

• attacks (str) – set time over which increase of volume is determined

• decays (str) – set time over which decrease of volume is determined

• points (str) – set points of transfer function

• soft-knee (float) – set soft-knee

• gain (float) – set output gain

• volume (float) – set initial volume

• delay (float) – set delay for samples before sending them to volume adjuster

zprp_ffmpeg.generated_filters.compensationdelay(graph: Stream, mm: int | None = None, cm: int | None = None, m: int | None = None, dry: float | None = None, wet: float | None = None, temp: int | None = None)

Audio Compensation Delay Line.

Parameters:

• mm (int) – set mm distance

• cm (int) – set cm distance

• m (int) – set meter distance

• dry (float) – set dry amount

• wet (float) – set wet amount

• temp (int) – set temperature °C

zprp_ffmpeg.generated_filters.convolution(graph: Stream, _0m: str | None = None, _1m: str | None = None, _2m: str | None = None, _3m: str | None = None, _0rdiv: float | None = None, _1rdiv: float | None = None, _2rdiv: float | None = None, _3rdiv: float | None = None, _0bias: float | None = None, _1bias: float | None = None, _2bias: float | None = None, _3bias: float | None = None, _0mode: str | None = None, _1mode: str | None = None, _2mode: str | None = None, _3mode: str | None = None)

Apply convolution filter.

Parameters:

• 0m (str) – set matrix for 1st plane

• 1m (str) – set matrix for 2nd plane

• 2m (str) – set matrix for 3rd plane

• 3m (str) – set matrix for 4th plane

• 0rdiv (float) – set rdiv for 1st plane

• 1rdiv (float) – set rdiv for 2nd plane

• 2rdiv (float) – set rdiv for 3rd plane

• 3rdiv (float) – set rdiv for 4th plane

• 0bias (float) – set bias for 1st plane

• 1bias (float) – set bias for 2nd plane

• 2bias (float) – set bias for 3rd plane

• 3bias (float) – set bias for 4th plane

• 0mode (str) – set matrix mode for 1st plane possible values: square, row, column

• 1mode (str) – set matrix mode for 2nd plane possible values: square, row, column

• 2mode (str) – set matrix mode for 3rd plane possible values: square, row, column

• 3mode (str) – set matrix mode for 4th plane possible values: square, row, column

zprp_ffmpeg.generated_filters.convolve(graph: Stream, planes: int | None = None, impulse: str | None = None, noise: float | None = None)

Convolve first video stream with second video stream.

Parameters:

• planes (int) – set planes to convolve

• impulse (str) – when to process impulses possible values: first, all

• noise (float) – set noise

zprp_ffmpeg.generated_filters.copy(graph: Stream)

Copy the input video unchanged to the output.

zprp_ffmpeg.generated_filters.corr(graph: Stream)

Calculate the correlation between two video streams.

zprp_ffmpeg.generated_filters.cover_rect(graph: Stream, cover: str | None = None, mode: str | None = None)

Find and cover a user specified object.

Parameters:

• cover (str) – cover bitmap filename

• mode (str) – set removal mode possible values: cover, blur

zprp_ffmpeg.generated_filters.crop(graph: Stream, out_w: str | None = None, out_h: str | None = None, x: str | None = None, y: str | None = None, keep_aspect: bool | None = None, exact: bool | None = None)

Crop the input video.

Parameters:

• out_w (str) – set the width crop area expression

• out_h (str) – set the height crop area expression

• x (str) – set the x crop area expression

• y (str) – set the y crop area expression

• keep_aspect (bool) – keep aspect ratio

• exact (bool) – do exact cropping

zprp_ffmpeg.generated_filters.cropdetect(graph: Stream, limit: float | None = None, round: int | None = None, reset: int | None = None, skip: int | None = None, max_outliers: int | None = None, mode: str | None = None, high: float | None = None, low: float | None = None, mv_threshold: int | None = None)

Auto-detect crop size.

Parameters:

• limit (float) – Threshold below which the pixel is considered black

• round (int) – Value by which the width/height should be divisible

• reset (int) – Recalculate the crop area after this many frames

• skip (int) – Number of initial frames to skip

• max_outliers (int) – Threshold count of outliers

• mode (str) – set mode possible values: black, mvedges

• high (float) – Set high threshold for edge detection

• low (float) – Set low threshold for edge detection

• mv_threshold (int) – motion vector threshold when estimating video window size

zprp_ffmpeg.generated_filters.crossfeed(graph: Stream, strength: float | None = None, range: float | None = None, slope: float | None = None, level_in: float | None = None, level_out: float | None = None, block_size: int | None = None)

Apply headphone crossfeed filter.

Parameters:

• strength (float) – set crossfeed strength

• range (float) – set soundstage wideness

• slope (float) – set curve slope

• level_in (float) – set level in

• level_out (float) – set level out

• block_size (int) – set the block size

zprp_ffmpeg.generated_filters.crystalizer(graph: Stream, i: float | None = None, c: bool | None = None)

Simple audio noise sharpening filter.

Parameters:

• i (float) – set intensity

• c (bool) – enable clipping

zprp_ffmpeg.generated_filters.cue(graph: Stream)

Delay filtering to match a cue.

zprp_ffmpeg.generated_filters.curves(graph: Stream, preset: str | None = None, master: str | None = None, m: str | None = None, red: str | None = None, r: str | None = None, green: str | None = None, g: str | None = None, blue: str | None = None, b: str | None = None, all: str | None = None, psfile: str | None = None, plot: str | None = None, interp: str | None = None)

Adjust components curves.

Parameters:

• preset (str) – select a color curves preset possible values: none, color_negative, cross_process, darker, increase_contrast, lighter, linear_contrast, medium_contrast, negative, strong_contrast, vintage

• master (str) – set master points coordinates

• m (str) – set master points coordinates

• red (str) – set red points coordinates

• r (str) – set red points coordinates

• green (str) – set green points coordinates

• g (str) – set green points coordinates

• blue (str) – set blue points coordinates

• b (str) – set blue points coordinates

• all (str) – set points coordinates for all components

• psfile (str) – set Photoshop curves file name

• plot (str) – save Gnuplot script of the curves in specified file

• interp (str) – specify the kind of interpolation possible values: natural, pchip

zprp_ffmpeg.generated_filters.datascope(graph: Stream, size: int | None = None, x: int | None = None, y: int | None = None, mode: str | None = None, axis: bool | None = None, opacity: float | None = None, format: str | None = None, components: int | None = None)

Video data analysis.

Parameters:

• size (int) – set output size

• x (int) – set x offset

• y (int) – set y offset

• mode (str) – set scope mode possible values: mono, color, color2

• axis (bool) – draw column/row numbers

• opacity (float) – set background opacity

• format (str) – set display number format possible values: hex, dec

• components (int) – set components to display

zprp_ffmpeg.generated_filters.dblur(graph: Stream, angle: float | None = None, radius: float | None = None, planes: int | None = None)

Apply Directional Blur filter.

Parameters:

• angle (float) – set angle

• radius (float) – set radius

• planes (int) – set planes to filter

zprp_ffmpeg.generated_filters.dcshift(graph: Stream, shift: float | None = None, limitergain: float | None = None)

Apply a DC shift to the audio.

Parameters:

• shift (float) – set DC shift

• limitergain (float) – set limiter gain

zprp_ffmpeg.generated_filters.dctdnoiz(graph: Stream, sigma: float | None = None, overlap: int | None = None, expr: str | None = None, n: int | None = None)

Denoise frames using 2D DCT.

Parameters:

• sigma (float) – set noise sigma constant

• overlap (int) – set number of block overlapping pixels

• expr (str) – set coefficient factor expression

• n (int) – set the block size, expressed in bits

zprp_ffmpeg.generated_filters.deband(graph: Stream, _1thr: float | None = None, _2thr: float | None = None, _3thr: float | None = None, _4thr: float | None = None, range: int | None = None, direction: float | None = None, blur: bool | None = None, coupling: bool | None = None)

Debands video.

Parameters:

• 1thr (float) – set 1st plane threshold

• 2thr (float) – set 2nd plane threshold

• 3thr (float) – set 3rd plane threshold

• 4thr (float) – set 4th plane threshold

• range (int) – set range

• direction (float) – set direction

• blur (bool) – set blur

• coupling (bool) – set plane coupling

zprp_ffmpeg.generated_filters.deblock(graph: Stream, filter: str | None = None, block: int | None = None, alpha: float | None = None, beta: float | None = None, gamma: float | None = None, delta: float | None = None, planes: int | None = None)

Deblock video.

Parameters:

• filter (str) – set type of filter possible values: weak, strong

• block (int) – set size of block

• alpha (float) – set 1st detection threshold

• beta (float) – set 2nd detection threshold

• gamma (float) – set 3rd detection threshold

• delta (float) – set 4th detection threshold

• planes (int) – set planes to filter

zprp_ffmpeg.generated_filters.decimate(graph: Stream, cycle: int | None = None, dupthresh: float | None = None, scthresh: float | None = None, blockx: int | None = None, blocky: int | None = None, ppsrc: bool | None = None, chroma: bool | None = None, mixed: bool | None = None)

Decimate frames (post field matching filter).

Parameters:

• cycle (int) – set the number of frame from which one will be dropped

• dupthresh (float) – set duplicate threshold

• scthresh (float) – set scene change threshold

• blockx (int) – set the size of the x-axis blocks used during metric calculations

• blocky (int) – set the size of the y-axis blocks used during metric calculations

• ppsrc (bool) – mark main input as a pre-processed input and activate clean source input stream

• chroma (bool) – set whether or not chroma is considered in the metric calculations

• mixed (bool) – set whether or not the input only partially contains content to be decimated

zprp_ffmpeg.generated_filters.deconvolve(graph: Stream, planes: int | None = None, impulse: str | None = None, noise: float | None = None)

Deconvolve first video stream with second video stream.

Parameters:

• planes (int) – set planes to deconvolve

• impulse (str) – when to process impulses possible values: first, all

• noise (float) – set noise

zprp_ffmpeg.generated_filters.dedot(graph: Stream, m: str | None = None, lt: float | None = None, tl: float | None = None, tc: float | None = None, ct: float | None = None)

Reduce cross-luminance and cross-color.

Parameters:

• m (str) – set filtering mode possible values: dotcrawl, rainbows

• lt (float) – set spatial luma threshold

• tl (float) – set tolerance for temporal luma

• tc (float) – set tolerance for chroma temporal variation

• ct (float) – set temporal chroma threshold

zprp_ffmpeg.generated_filters.deesser(graph: Stream, i: float | None = None, m: float | None = None, f: float | None = None, s: str | None = None)

Apply de-essing to the audio.

Parameters:

• i (float) – set intensity

• m (float) – set max deessing

• f (float) – set frequency

• s (str) – set output mode possible values: i, o, e

zprp_ffmpeg.generated_filters.deflate(graph: Stream)

Apply deflate effect.

zprp_ffmpeg.generated_filters.deflicker(graph: Stream, size: int | None = None, mode: str | None = None, bypass: bool | None = None)

Remove temporal frame luminance variations.

Parameters:

• size (int) – set how many frames to use

• mode (str) – set how to smooth luminance possible values: am, gm, hm, qm, cm, pm, median

• bypass (bool) – leave frames unchanged

zprp_ffmpeg.generated_filters.dejudder(graph: Stream, cycle: int | None = None)

Remove judder produced by pullup.

Parameters:

cycle (int) – set the length of the cycle to use for dejuddering

zprp_ffmpeg.generated_filters.delogo(graph: Stream, x: str | None = None, y: str | None = None, w: str | None = None, h: str | None = None, show: bool | None = None)

Remove logo from input video.

Parameters:

• x (str) – set logo x position

• y (str) – set logo y position

• w (str) – set logo width

• h (str) – set logo height

• show (bool) – show delogo area

zprp_ffmpeg.generated_filters.derain(graph: Stream, filter_type: str | None = None, dnn_backend: int | None = None, model: str | None = None, input: str | None = None, output: str | None = None)

Apply derain filter to the input.

Parameters:

• filter_type (str) – filter type(derain/dehaze) possible values: derain, dehaze

• dnn_backend (int) – DNN backend

• model (str) – path to model file

• input (str) – input name of the model

• output (str) – output name of the model

zprp_ffmpeg.generated_filters.deshake(graph: Stream, x: int | None = None, y: int | None = None, w: int | None = None, h: int | None = None, rx: int | None = None, ry: int | None = None, edge: str | None = None, blocksize: int | None = None, contrast: int | None = None, search: str | None = None, filename: str | None = None, opencl: bool | None = None)

Stabilize shaky video.

Parameters:

• x (int) – set x for the rectangular search area

• y (int) – set y for the rectangular search area

• w (int) – set width for the rectangular search area

• h (int) – set height for the rectangular search area

• rx (int) – set x for the rectangular search area

• ry (int) – set y for the rectangular search area

• edge (str) – set edge mode possible values: blank, original, clamp, mirror

• blocksize (int) – set motion search blocksize

• contrast (int) – set contrast threshold for blocks

• search (str) – set search strategy possible values: exhaustive, less

• filename (str) – set motion search detailed log file name

• opencl (bool) – ignored

zprp_ffmpeg.generated_filters.deshake_opencl(graph: Stream, tripod: bool | None = None, debug: bool | None = None, adaptive_crop: bool | None = None, refine_features: bool | None = None, smooth_strength: float | None = None, smooth_window_multiplier: float | None = None)

Feature-point based video stabilization filter

Parameters:

• tripod (bool) – simulates a tripod by preventing any camera movement whatsoever from the original frame

• debug (bool) – turn on additional debugging information

• adaptive_crop (bool) – attempt to subtly crop borders to reduce mirrored content

• refine_features (bool) – refine feature point locations at a sub-pixel level

• smooth_strength (float) – smoothing strength (0 attempts to adaptively determine optimal strength)

• smooth_window_multiplier (float) – multiplier for number of frames to buffer for motion data

zprp_ffmpeg.generated_filters.despill(graph: Stream, type: str | None = None, mix: float | None = None, expand: float | None = None, red: float | None = None, green: float | None = None, blue: float | None = None, brightness: float | None = None, alpha: bool | None = None)

Despill video.

Parameters:

• type (str) – set the screen type possible values: green, blue

• mix (float) – set the spillmap mix

• expand (float) – set the spillmap expand

• red (float) – set red scale

• green (float) – set green scale

• blue (float) – set blue scale

• brightness (float) – set brightness

• alpha (bool) – change alpha component

zprp_ffmpeg.generated_filters.detelecine(graph: Stream, first_field: str | None = None, pattern: str | None = None, start_frame: int | None = None)

Apply an inverse telecine pattern.

Parameters:

• first_field (str) – select first field possible values: top, t, bottom, b

• pattern (str) – pattern that describe for how many fields a frame is to be displayed

• start_frame (int) – position of first frame with respect to the pattern if stream is cut

zprp_ffmpeg.generated_filters.dialoguenhance(graph: Stream, original: float | None = None, enhance: float | None = None, voice: float | None = None)

Audio Dialogue Enhancement.

Parameters:

• original (float) – set original center factor

• enhance (float) – set dialogue enhance factor

• voice (float) – set voice detection factor

zprp_ffmpeg.generated_filters.dilation(graph: Stream)

Apply dilation effect.

zprp_ffmpeg.generated_filters.displace(graph: Stream, edge: str | None = None)

Displace pixels.

Parameters:

edge (str) – set edge mode possible values: blank, smear, wrap, mirror

zprp_ffmpeg.generated_filters.dnn_classify(graph: Stream, dnn_backend: int | None = None, model: str | None = None, input: str | None = None, output: str | None = None, backend_configs: str | None = None, options: str | None = None, _async: bool | None = None, confidence: float | None = None, labels: str | None = None, target: str | None = None)

Apply DNN classify filter to the input.

Parameters:

• dnn_backend (int) – DNN backend

• model (str) – path to model file

• input (str) – input name of the model

• output (str) – output name of the model

• backend_configs (str) – backend configs

• options (str) – backend configs (deprecated, use backend_configs)

• async (bool) – use DNN async inference (ignored, use backend_configs=’async=1’)

• confidence (float) – threshold of confidence

• labels (str) – path to labels file

• target (str) – which one to be classified

zprp_ffmpeg.generated_filters.dnn_detect(graph: Stream, dnn_backend: int | None = None, model: str | None = None, input: str | None = None, output: str | None = None, backend_configs: str | None = None, options: str | None = None, _async: bool | None = None, confidence: float | None = None, labels: str | None = None, model_type: str | None = None, cell_w: int | None = None, cell_h: int | None = None, nb_classes: int | None = None, anchors: str | None = None)

Apply DNN detect filter to the input.

Parameters:

• dnn_backend (int) – DNN backend

• model (str) – path to model file

• input (str) – input name of the model

• output (str) – output name of the model

• backend_configs (str) – backend configs

• options (str) – backend configs (deprecated, use backend_configs)

• async (bool) – use DNN async inference (ignored, use backend_configs=’async=1’)

• confidence (float) – threshold of confidence

• labels (str) – path to labels file

• model_type (str) – DNN detection model type possible values: ssd, yolo, yolov3, yolov4

• cell_w (int) – cell width

• cell_h (int) – cell height

• nb_classes (int) – The number of class

• anchors (str) – anchors, splited by ‘&’

zprp_ffmpeg.generated_filters.dnn_processing(graph: Stream, dnn_backend: int | None = None, model: str | None = None, input: str | None = None, output: str | None = None, backend_configs: str | None = None, options: str | None = None, _async: bool | None = None)

Apply DNN processing filter to the input.

Parameters:

• dnn_backend (int) – DNN backend

• model (str) – path to model file

• input (str) – input name of the model

• output (str) – output name of the model

• backend_configs (str) – backend configs

• options (str) – backend configs (deprecated, use backend_configs)

• async (bool) – use DNN async inference (ignored, use backend_configs=’async=1’)

zprp_ffmpeg.generated_filters.doubleweave(graph: Stream)

Weave input video fields into double number of frames.

zprp_ffmpeg.generated_filters.drawbox(graph: Stream, x: str | None = None, y: str | None = None, width: str | None = None, height: str | None = None, color: str | None = None, thickness: str | None = None, replace: bool | None = None, box_source: str | None = None)

Draw a colored box on the input video.

Parameters:

• x (str) – set horizontal position of the left box edge

• y (str) – set vertical position of the top box edge

• width (str) – set width of the box

• height (str) – set height of the box

• color (str) – set color of the box

• thickness (str) – set the box thickness

• replace (bool) – replace color & alpha

• box_source (str) – use datas from bounding box in side data

zprp_ffmpeg.generated_filters.drawgraph(graph: Stream, m1: str | None = None, fg1: str | None = None, m2: str | None = None, fg2: str | None = None, m3: str | None = None, fg3: str | None = None, m4: str | None = None, fg4: str | None = None, bg: str | None = None, min: float | None = None, max: float | None = None, mode: str | None = None, slide: str | None = None, size: int | None = None, rate: str | None = None)

Draw a graph using input video metadata.

Parameters:

• m1 (str) – set 1st metadata key

• fg1 (str) – set 1st foreground color expression

• m2 (str) – set 2nd metadata key

• fg2 (str) – set 2nd foreground color expression

• m3 (str) – set 3rd metadata key

• fg3 (str) – set 3rd foreground color expression

• m4 (str) – set 4th metadata key

• fg4 (str) – set 4th foreground color expression

• bg (str) – set background color

• min (float) – set minimal value

• max (float) – set maximal value

• mode (str) – set graph mode possible values: bar, dot, line

• slide (str) – set slide mode possible values: frame, replace, scroll, rscroll, picture

• size (int) – set graph size

• rate (str) – set video rate

zprp_ffmpeg.generated_filters.drawgrid(graph: Stream, x: str | None = None, y: str | None = None, width: str | None = None, height: str | None = None, color: str | None = None, thickness: str | None = None, replace: bool | None = None)

Draw a colored grid on the input video.

Parameters:

• x (str) – set horizontal offset

• y (str) – set vertical offset

• width (str) – set width of grid cell

• height (str) – set height of grid cell

• color (str) – set color of the grid

• thickness (str) – set grid line thickness

• replace (bool) – replace color & alpha

zprp_ffmpeg.generated_filters.drmeter(graph: Stream, length: float | None = None)

Measure audio dynamic range.

Parameters:

length (float) – set the window length

zprp_ffmpeg.generated_filters.dynaudnorm(graph: Stream, framelen: int | None = None, gausssize: int | None = None, peak: float | None = None, maxgain: float | None = None, targetrms: float | None = None, coupling: bool | None = None, correctdc: bool | None = None, altboundary: bool | None = None, compress: float | None = None, threshold: float | None = None, channels: str | None = None, overlap: float | None = None, curve: str | None = None)

Dynamic Audio Normalizer.

Parameters:

• framelen (int) – set the frame length in msec

• gausssize (int) – set the filter size

• peak (float) – set the peak value

• maxgain (float) – set the max amplification

• targetrms (float) – set the target RMS

• coupling (bool) – set channel coupling

• correctdc (bool) – set DC correction

• altboundary (bool) – set alternative boundary mode

• compress (float) – set the compress factor

• threshold (float) – set the threshold value

• channels (str) – set channels to filter

• overlap (float) – set the frame overlap

• curve (str) – set the custom peak mapping curve

zprp_ffmpeg.generated_filters.earwax(graph: Stream)

Widen the stereo image.

zprp_ffmpeg.generated_filters.edgedetect(graph: Stream, high: float | None = None, low: float | None = None, mode: str | None = None, planes: str | None = None)

Detect and draw edge.

Parameters:

• high (float) – set high threshold

• low (float) – set low threshold

• mode (str) – set mode possible values: wires, colormix, canny

• planes (str) – set planes to filter possible values: y, u, v, r, g, b

zprp_ffmpeg.generated_filters.elbg(graph: Stream, codebook_length: int | None = None, nb_steps: int | None = None, seed: int | None = None, pal8: bool | None = None, use_alpha: bool | None = None)

Apply posterize effect, using the ELBG algorithm.

Parameters:

• codebook_length (int) – set codebook length

• nb_steps (int) – set max number of steps used to compute the mapping

• seed (int) – set the random seed

• pal8 (bool) – set the pal8 output

• use_alpha (bool) – use alpha channel for mapping

zprp_ffmpeg.generated_filters.entropy(graph: Stream, mode: str | None = None)

Measure video frames entropy.

Parameters:

mode (str) – set kind of histogram entropy measurement possible values: normal, diff

zprp_ffmpeg.generated_filters.epx(graph: Stream, n: int | None = None)

Scale the input using EPX algorithm.

Parameters:

n (int) – set scale factor

zprp_ffmpeg.generated_filters.eq(graph: Stream, contrast: str | None = None, brightness: str | None = None, saturation: str | None = None, gamma: str | None = None, gamma_r: str | None = None, gamma_g: str | None = None, gamma_b: str | None = None, gamma_weight: str | None = None, eval: str | None = None)

Adjust brightness, contrast, gamma, and saturation.

Parameters:

• contrast (str) – set the contrast adjustment, negative values give a negative image

• brightness (str) – set the brightness adjustment

• saturation (str) – set the saturation adjustment

• gamma (str) – set the initial gamma value

• gamma_r (str) – gamma value for red

• gamma_g (str) – gamma value for green

• gamma_b (str) – gamma value for blue

• gamma_weight (str) – set the gamma weight which reduces the effect of gamma on bright areas

• eval (str) – specify when to evaluate expressions possible values: init, frame

zprp_ffmpeg.generated_filters.equalizer(graph: Stream, frequency: float | None = None, width_type: str | None = None, width: float | None = None, gain: float | None = None, mix: float | None = None, channels: str | None = None, normalize: bool | None = None, transform: str | None = None, precision: str | None = None, blocksize: int | None = None)

Apply two-pole peaking equalization (EQ) filter.

Parameters:

• frequency (float) – set central frequency

• width_type (str) – set filter-width type possible values: h, q, o, s, k

• width (float) – set width

• gain (float) – set gain

• mix (float) – set mix

• channels (str) – set channels to filter

• normalize (bool) – normalize coefficients

• transform (str) – set transform type possible values: di, dii, tdi, tdii, latt, svf, zdf

• precision (str) – set filtering precision possible values: auto, s16, s32, f32, f64

• blocksize (int) – set the block size

zprp_ffmpeg.generated_filters.erosion(graph: Stream)

Apply erosion effect.

zprp_ffmpeg.generated_filters.estdif(graph: Stream, mode: str | None = None, parity: str | None = None, deint: str | None = None, rslope: int | None = None, redge: int | None = None, ecost: int | None = None, mcost: int | None = None, dcost: int | None = None, interp: str | None = None)

Apply Edge Slope Tracing deinterlace.

Parameters:

• mode (str) – specify the mode possible values: frame, field

• parity (str) – specify the assumed picture field parity possible values: tff, bff, auto

• deint (str) – specify which frames to deinterlace possible values: all, interlaced

• rslope (int) – specify the search radius for edge slope tracing

• redge (int) – specify the search radius for best edge matching

• ecost (int) – specify the edge cost for edge matching

• mcost (int) – specify the middle cost for edge matching

• dcost (int) – specify the distance cost for edge matching

• interp (str) – specify the type of interpolation possible values: 2p, 4p, 6p

zprp_ffmpeg.generated_filters.exposure(graph: Stream, exposure: float | None = None, black: float | None = None)

Adjust exposure of the video stream.

Parameters:

• exposure (float) – set the exposure correction

• black (float) – set the black level correction

zprp_ffmpeg.generated_filters.extrastereo(graph: Stream, m: float | None = None, c: bool | None = None)

Increase difference between stereo audio channels.

Parameters:

• m (float) – set the difference coefficient

• c (bool) – enable clipping

zprp_ffmpeg.generated_filters.fade(graph: Stream, type: str | None = None, start_frame: int | None = None, nb_frames: int | None = None, alpha: bool | None = None, start_time: int | None = None, duration: int | None = None, color: str | None = None)

Fade in/out input video.

Parameters:

• type (str) – set the fade direction possible values: in, out

• start_frame (int) – Number of the first frame to which to apply the effect.

• nb_frames (int) – Number of frames to which the effect should be applied.

• alpha (bool) – fade alpha if it is available on the input

• start_time (int) – Number of seconds of the beginning of the effect.

• duration (int) – Duration of the effect in seconds.

• color (str) – set color

zprp_ffmpeg.generated_filters.feedback(graph: Stream, x: int | None = None, y: int | None = None, w: int | None = None, h: int | None = None)

Apply feedback video filter.

Parameters:

• x (int) – set top left crop position

• y (int) – set top left crop position

• w (int) – set crop size

• h (int) – set crop size

zprp_ffmpeg.generated_filters.fftdnoiz(graph: Stream, sigma: float | None = None, amount: float | None = None, block: int | None = None, overlap: float | None = None, method: str | None = None, prev: int | None = None, next: int | None = None, planes: int | None = None, window: str | None = None)

Denoise frames using 3D FFT.

Parameters:

• sigma (float) – set denoise strength

• amount (float) – set amount of denoising

• block (int) – set block size

• overlap (float) – set block overlap

• method (str) – set method of denoising possible values: wiener, hard

• prev (int) – set number of previous frames for temporal denoising

• next (int) – set number of next frames for temporal denoising

• planes (int) – set planes to filter

• window (str) – set window function possible values: rect, bartlett, hann, hanning, hamming, blackman, welch, flattop, bharris, bnuttall, bhann, sine, nuttall, lanczos, gauss, tukey, dolph, cauchy, parzen, poisson, bohman, kaiser

zprp_ffmpeg.generated_filters.fftfilt(graph: Stream, dc_Y: int | None = None, dc_U: int | None = None, dc_V: int | None = None, weight_Y: str | None = None, weight_U: str | None = None, weight_V: str | None = None, eval: str | None = None)

Apply arbitrary expressions to pixels in frequency domain.

Parameters:

• dc_Y (int) – adjust gain in Y plane

• dc_U (int) – adjust gain in U plane

• dc_V (int) – adjust gain in V plane

• weight_Y (str) – set luminance expression in Y plane

• weight_U (str) – set chrominance expression in U plane

• weight_V (str) – set chrominance expression in V plane

• eval (str) – specify when to evaluate expressions possible values: init, frame

zprp_ffmpeg.generated_filters.field(graph: Stream, type: str | None = None)

Extract a field from the input video.

Parameters:

type (str) – set field type (top or bottom) possible values: top, bottom

zprp_ffmpeg.generated_filters.fieldhint(graph: Stream, hint: str | None = None, mode: str | None = None)

Field matching using hints.

Parameters:

• hint (str) – set hint file

• mode (str) – set hint mode possible values: absolute, relative, pattern

zprp_ffmpeg.generated_filters.fieldmatch(graph: Stream, order: str | None = None, mode: str | None = None, ppsrc: bool | None = None, field: str | None = None, mchroma: bool | None = None, y0: int | None = None, y1: int | None = None, scthresh: float | None = None, combmatch: str | None = None, combdbg: str | None = None, cthresh: int | None = None, chroma: bool | None = None, blockx: int | None = None, blocky: int | None = None, combpel: int | None = None)

Field matching for inverse telecine.

Parameters:

• order (str) – specify the assumed field order possible values: auto, bff, tff

• mode (str) – set the matching mode or strategy to use possible values: pc, pc_n, pc_u, pc_n_ub, pcn, pcn_ub

• ppsrc (bool) – mark main input as a pre-processed input and activate clean source input stream

• field (str) – set the field to match from possible values: auto, bottom, top

• mchroma (bool) – set whether or not chroma is included during the match comparisons

• y0 (int) – define an exclusion band which excludes the lines between y0 and y1 from the field matching decision

• y1 (int) – define an exclusion band which excludes the lines between y0 and y1 from the field matching decision

• scthresh (float) – set scene change detection threshold

• combmatch (str) – set combmatching mode possible values: none, sc, full

• combdbg (str) – enable comb debug possible values: none, pcn, pcnub

• cthresh (int) – set the area combing threshold used for combed frame detection

• chroma (bool) – set whether or not chroma is considered in the combed frame decision

• blockx (int) – set the x-axis size of the window used during combed frame detection

• blocky (int) – set the y-axis size of the window used during combed frame detection

• combpel (int) – set the number of combed pixels inside any of the blocky by blockx size blocks on the frame for the frame to be detected as combed

zprp_ffmpeg.generated_filters.fieldorder(graph: Stream, order: str | None = None)

Set the field order.

Parameters:

order (str) – output field order possible values: bff, tff

zprp_ffmpeg.generated_filters.fillborders(graph: Stream, left: int | None = None, right: int | None = None, top: int | None = None, bottom: int | None = None, mode: str | None = None, color: str | None = None)

Fill borders of the input video.

Parameters:

• left (int) – set the left fill border

• right (int) – set the right fill border

• top (int) – set the top fill border

• bottom (int) – set the bottom fill border

• mode (str) – set the fill borders mode possible values: smear, mirror, fixed, reflect, wrap, fade, margins

• color (str) – set the color for the fixed/fade mode

zprp_ffmpeg.generated_filters.find_rect(graph: Stream, object: str | None = None, threshold: float | None = None, mipmaps: int | None = None, xmin: int | None = None, ymin: int | None = None, xmax: int | None = None, ymax: int | None = None, discard: bool | None = None)

Find a user specified object.

Parameters:

• object (str) – object bitmap filename

• threshold (float) – set threshold

• mipmaps (int) – set mipmaps

zprp_ffmpeg.generated_filters.firequalizer(graph: Stream, gain: str | None = None, gain_entry: str | None = None, delay: float | None = None, accuracy: float | None = None, wfunc: str | None = None, fixed: bool | None = None, multi: bool | None = None, zero_phase: bool | None = None, scale: str | None = None, dumpfile: str | None = None, dumpscale: int | None = None, fft2: bool | None = None, min_phase: bool | None = None)

Finite Impulse Response Equalizer.

Parameters:

• gain (str) – set gain curve

• gain_entry (str) – set gain entry

• delay (float) – set delay

• accuracy (float) – set accuracy

• wfunc (str) – set window function possible values: rectangular, hann, hamming, blackman, nuttall3, mnuttall3, nuttall, bnuttall, bharris, tukey

• fixed (bool) – set fixed frame samples

• multi (bool) – set multi channels mode

• zero_phase (bool) – set zero phase mode

• scale (str) – set gain scale possible values: linlin, linlog, loglin, loglog

• dumpfile (str) – set dump file

• dumpscale (int) – set dump scale

• fft2 (bool) – set 2-channels fft

• min_phase (bool) – set minimum phase mode

zprp_ffmpeg.generated_filters.flanger(graph: Stream, delay: float | None = None, depth: float | None = None, regen: float | None = None, width: float | None = None, speed: float | None = None, shape: str | None = None, phase: float | None = None, interp: str | None = None)

Apply a flanging effect to the audio.

Parameters:

• delay (float) – base delay in milliseconds

• depth (float) – added swept delay in milliseconds

• regen (float) – percentage regeneration (delayed signal feedback)

• width (float) – percentage of delayed signal mixed with original

• speed (float) – sweeps per second (Hz)

• shape (str) – swept wave shape possible values: triangular, t, sinusoidal, s

• phase (float) – swept wave percentage phase-shift for multi-channel

• interp (str) – delay-line interpolation possible values: linear, quadratic

zprp_ffmpeg.generated_filters.flip_vulkan(graph: Stream)

Flip both horizontally and vertically

zprp_ffmpeg.generated_filters.floodfill(graph: Stream, x: int | None = None, y: int | None = None, s0: int | None = None, s1: int | None = None, s2: int | None = None, s3: int | None = None, d0: int | None = None, d1: int | None = None, d2: int | None = None, d3: int | None = None)

Fill area with same color with another color.

Parameters:

• x (int) – set pixel x coordinate

• y (int) – set pixel y coordinate

• s0 (int) – set source #0 component value

• s1 (int) – set source #1 component value

• s2 (int) – set source #2 component value

• s3 (int) – set source #3 component value

• d0 (int) – set destination #0 component value

• d1 (int) – set destination #1 component value

• d2 (int) – set destination #2 component value

• d3 (int) – set destination #3 component value

zprp_ffmpeg.generated_filters.format(graph: Stream)

Convert the input video to one of the specified pixel formats.

zprp_ffmpeg.generated_filters.fps(graph: Stream, fps: str | None = None, start_time: float | None = None, round: str | None = None, eof_action: str | None = None)

Force constant framerate.

Parameters:

• fps (str) – A string describing desired output framerate

• start_time (float) – Assume the first PTS should be this value.

• round (str) – set rounding method for timestamps possible values: zero, inf, down, up, near

• eof_action (str) – action performed for last frame possible values: round, pass

zprp_ffmpeg.generated_filters.framepack(graph: Stream, format: str | None = None)

Generate a frame packed stereoscopic video.

Parameters:

format (str) – Frame pack output format possible values: sbs, tab, frameseq, lines, columns

zprp_ffmpeg.generated_filters.framerate(graph: Stream, fps: str | None = None, interp_start: int | None = None, interp_end: int | None = None, scene: float | None = None, flags: str | None = None)

Upsamples or downsamples progressive source between specified frame rates.

Parameters:

• fps (str) – required output frames per second rate

• interp_start (int) – point to start linear interpolation

• interp_end (int) – point to end linear interpolation

• scene (float) – scene change level

• flags (str) – set flags possible values: scene_change_detect, scd

zprp_ffmpeg.generated_filters.framestep(graph: Stream, step: int | None = None)

Select one frame every N frames.

Parameters:

step (int) – set frame step

zprp_ffmpeg.generated_filters.freezedetect(graph: Stream, n: float | None = None, d: int | None = None)

Detects frozen video input.

Parameters:

• n (float) – set noise tolerance

• d (int) – set minimum duration in seconds

zprp_ffmpeg.generated_filters.freezeframes(graph: Stream, first: int | None = None, last: int | None = None, replace: int | None = None)

Freeze video frames.

Parameters:

• first (int) – set first frame to freeze

• last (int) – set last frame to freeze

• replace (int) – set frame to replace

zprp_ffmpeg.generated_filters.fspp(graph: Stream, quality: int | None = None, qp: int | None = None, strength: int | None = None, use_bframe_qp: bool | None = None)

Apply Fast Simple Post-processing filter.

Parameters:

• quality (int) – set quality

• qp (int) – force a constant quantizer parameter

• strength (int) – set filter strength

• use_bframe_qp (bool) – use B-frames’ QP

zprp_ffmpeg.generated_filters.fsync(graph: Stream, file: str | None = None)

Synchronize video frames from external source.

Parameters:

file (str) – set the file name to use for frame sync

zprp_ffmpeg.generated_filters.gblur(graph: Stream, sigma: float | None = None, steps: int | None = None, planes: int | None = None, sigmaV: float | None = None)

Apply Gaussian Blur filter.

Parameters:

• sigma (float) – set sigma

• steps (int) – set number of steps

• planes (int) – set planes to filter

• sigmaV (float) – set vertical sigma

zprp_ffmpeg.generated_filters.gblur_vulkan(graph: Stream, sigma: float | None = None, sigmaV: float | None = None, planes: int | None = None, size: int | None = None, sizeV: int | None = None)

Gaussian Blur in Vulkan

Parameters:

• sigma (float) – Set sigma

• sigmaV (float) – Set vertical sigma

• planes (int) – Set planes to filter

• size (int) – Set kernel size

• sizeV (int) – Set vertical kernel size

zprp_ffmpeg.generated_filters.geq(graph: Stream, lum_expr: str | None = None, lum: str | None = None, cb_expr: str | None = None, cb: str | None = None, cr_expr: str | None = None, cr: str | None = None, alpha_expr: str | None = None, a: str | None = None, red_expr: str | None = None, r: str | None = None, green_expr: str | None = None, g: str | None = None, blue_expr: str | None = None, b: str | None = None, interpolation: str | None = None)

Apply generic equation to each pixel.

Parameters:

• lum_expr (str) – set luminance expression

• lum (str) – set luminance expression

• cb_expr (str) – set chroma blue expression

• cb (str) – set chroma blue expression

• cr_expr (str) – set chroma red expression

• cr (str) – set chroma red expression

• alpha_expr (str) – set alpha expression

• a (str) – set alpha expression

• red_expr (str) – set red expression

• r (str) – set red expression

• green_expr (str) – set green expression

• g (str) – set green expression

• blue_expr (str) – set blue expression

• b (str) – set blue expression

• interpolation (str) – set interpolation method possible values: nearest, n, bilinear, b

zprp_ffmpeg.generated_filters.gradfun(graph: Stream, strength: float | None = None, radius: int | None = None)

Debands video quickly using gradients.

Parameters:

• strength (float) – The maximum amount by which the filter will change any one pixel.

• radius (int) – The neighborhood to fit the gradient to.

zprp_ffmpeg.generated_filters.gradients(graph: Stream, size: int | None = None, rate: str | None = None, c0: str | None = None, c1: str | None = None, c2: str | None = None, c3: str | None = None, c4: str | None = None, c5: str | None = None, c6: str | None = None, c7: str | None = None, x0: int | None = None, y0: int | None = None, x1: int | None = None, y1: int | None = None, nb_colors: int | None = None, seed: int | None = None, duration: int | None = None, speed: float | None = None, type: str | None = None)

Draw a gradients.

Parameters:

• size (int) – set frame size

• rate (str) – set frame rate

• c0 (str) – set 1st color

• c1 (str) – set 2nd color

• c2 (str) – set 3rd color

• c3 (str) – set 4th color

• c4 (str) – set 5th color

• c5 (str) – set 6th color

• c6 (str) – set 7th color

• c7 (str) – set 8th color

• x0 (int) – set gradient line source x0

• y0 (int) – set gradient line source y0

• x1 (int) – set gradient line destination x1

• y1 (int) – set gradient line destination y1

• nb_colors (int) – set the number of colors

• seed (int) – set the seed

• duration (int) – set video duration

• speed (float) – set gradients rotation speed

• type (str) – set gradient type possible values: linear, radial, circular, spiral, square

zprp_ffmpeg.generated_filters.graphmonitor(graph: Stream, size: int | None = None, opacity: float | None = None, mode: str | None = None, flags: str | None = None, rate: str | None = None)

Show various filtergraph stats.

Parameters:

• size (int) – set monitor size

• opacity (float) – set video opacity

• mode (str) – set mode possible values: full, compact, nozero, noeof, nodisabled

• flags (str) – set flags possible values: none, all, queue, frame_count_in, frame_count_out, frame_count_delta, pts, pts_delta, time, time_delta, timebase, format, size, rate, eof, sample_count_in, sample_count_out, sample_count_delta, disabled

• rate (str) – set video rate

zprp_ffmpeg.generated_filters.grayworld(graph: Stream)

Adjust white balance using LAB gray world algorithm

zprp_ffmpeg.generated_filters.greyedge(graph: Stream, difford: int | None = None, minknorm: int | None = None, sigma: float | None = None)

Estimates scene illumination by grey edge assumption.

Parameters:

• difford (int) – set differentiation order

• minknorm (int) – set Minkowski norm

• sigma (float) – set sigma

zprp_ffmpeg.generated_filters.guided(graph: Stream, radius: int | None = None, eps: float | None = None, mode: str | None = None, sub: int | None = None, guidance: str | None = None, planes: int | None = None)

Apply Guided filter.

Parameters:

• radius (int) – set the box radius

• eps (float) – set the regularization parameter (with square)

• mode (str) – set filtering mode (0: basic mode; 1: fast mode) possible values: basic, fast

• sub (int) – subsampling ratio for fast mode

• guidance (str) – set guidance mode (0: off mode; 1: on mode) possible values: off, on

• planes (int) – set planes to filter

zprp_ffmpeg.generated_filters.haas(graph: Stream, level_in: float | None = None, level_out: float | None = None, side_gain: float | None = None, middle_source: str | None = None, middle_phase: bool | None = None, left_delay: float | None = None, left_balance: float | None = None, left_gain: float | None = None, left_phase: bool | None = None, right_delay: float | None = None, right_balance: float | None = None, right_gain: float | None = None, right_phase: bool | None = None)

Apply Haas Stereo Enhancer.

Parameters:

• level_in (float) – set level in

• level_out (float) – set level out

• side_gain (float) – set side gain

• middle_source (str) – set middle source possible values: left, right, mid, side

• middle_phase (bool) – set middle phase

• left_delay (float) – set left delay

• left_balance (float) – set left balance

• left_gain (float) – set left gain

• left_phase (bool) – set left phase

• right_delay (float) – set right delay

• right_balance (float) – set right balance

• right_gain (float) – set right gain

• right_phase (bool) – set right phase

zprp_ffmpeg.generated_filters.haldclut(graph: Stream)

Adjust colors using a Hald CLUT.

zprp_ffmpeg.generated_filters.haldclutsrc(graph: Stream, level: int | None = None, rate: str | None = None, duration: int | None = None, sar: int | None = None)

Provide an identity Hald CLUT.

Parameters:

• level (int) – set level

• rate (str) – set video rate

• duration (int) – set video duration

• sar (int) – set video sample aspect ratio

zprp_ffmpeg.generated_filters.hdcd(graph: Stream, disable_autoconvert: bool | None = None, process_stereo: bool | None = None, cdt_ms: int | None = None, force_pe: bool | None = None, analyze_mode: str | None = None, bits_per_sample: str | None = None)

Apply High Definition Compatible Digital (HDCD) decoding.

Parameters:

• disable_autoconvert (bool) – Disable any format conversion or resampling in the filter graph.

• process_stereo (bool) – Process stereo channels together. Only apply target_gain when both channels match.

• cdt_ms (int) – Code detect timer period in ms.

• force_pe (bool) – Always extend peaks above -3dBFS even when PE is not signaled.

• analyze_mode (str) – Replace audio with solid tone and signal some processing aspect in the amplitude. possible values: off, lle, pe, cdt, tgm

• bits_per_sample (str) – Valid bits per sample (location of the true LSB). possible values: 16, 20, 24

zprp_ffmpeg.generated_filters.headphone(graph: Stream, map: str | None = None, gain: float | None = None, lfe: float | None = None, type: str | None = None, size: int | None = None, hrir: str | None = None)

Apply headphone binaural spatialization with HRTFs in additional streams.

Parameters:

• map (str) – set channels convolution mappings

• gain (float) – set gain in dB

• lfe (float) – set lfe gain in dB

• type (str) – set processing possible values: time, freq

• size (int) – set frame size

• hrir (str) – set hrir format possible values: stereo, multich

zprp_ffmpeg.generated_filters.hflip(graph: Stream)

Horizontally flip the input video.

zprp_ffmpeg.generated_filters.hflip_vulkan(graph: Stream)

Horizontally flip the input video in Vulkan

zprp_ffmpeg.generated_filters.highpass(graph: Stream, frequency: float | None = None, width_type: str | None = None, width: float | None = None, poles: int | None = None, mix: float | None = None, channels: str | None = None, normalize: bool | None = None, transform: str | None = None, precision: str | None = None, blocksize: int | None = None)

Apply a high-pass filter with 3dB point frequency.

Parameters:

• frequency (float) – set frequency

• width_type (str) – set filter-width type possible values: h, q, o, s, k

• width (float) – set width

• poles (int) – set number of poles

• mix (float) – set mix

• channels (str) – set channels to filter

• normalize (bool) – normalize coefficients

• transform (str) – set transform type possible values: di, dii, tdi, tdii, latt, svf, zdf

• precision (str) – set filtering precision possible values: auto, s16, s32, f32, f64

• blocksize (int) – set the block size

zprp_ffmpeg.generated_filters.highshelf(graph: Stream)

Apply a high shelf filter.

zprp_ffmpeg.generated_filters.hilbert(graph: Stream, sample_rate: int | None = None, taps: int | None = None, nb_samples: int | None = None, win_func: str | None = None)

Generate a Hilbert transform FIR coefficients.

Parameters:

• sample_rate (int) – set sample rate

• taps (int) – set number of taps

• nb_samples (int) – set the number of samples per requested frame

• win_func (str) – set window function possible values: rect, bartlett, hann, hanning, hamming, blackman, welch, flattop, bharris, bnuttall, bhann, sine, nuttall, lanczos, gauss, tukey, dolph, cauchy, parzen, poisson, bohman, kaiser

zprp_ffmpeg.generated_filters.histeq(graph: Stream, strength: float | None = None, intensity: float | None = None, antibanding: str | None = None)

Apply global color histogram equalization.

Parameters:

• strength (float) – set the strength

• intensity (float) – set the intensity

• antibanding (str) – set the antibanding level possible values: none, weak, strong

zprp_ffmpeg.generated_filters.histogram(graph: Stream, level_height: int | None = None, scale_height: int | None = None, display_mode: str | None = None, levels_mode: str | None = None, components: int | None = None, fgopacity: float | None = None, bgopacity: float | None = None, colors_mode: str | None = None)

Compute and draw a histogram.

Parameters:

• level_height (int) – set level height

• scale_height (int) – set scale height

• display_mode (str) – set display mode possible values: overlay, parade, stack

• levels_mode (str) – set levels mode possible values: linear, logarithmic

• components (int) – set color components to display

• fgopacity (float) – set foreground opacity

• bgopacity (float) – set background opacity

• colors_mode (str) – set colors mode possible values: whiteonblack, blackonwhite, whiteongray, blackongray, coloronblack, coloronwhite, colorongray, blackoncolor, whiteoncolor, grayoncolor

zprp_ffmpeg.generated_filters.hqdn3d(graph: Stream, luma_spatial: float | None = None, chroma_spatial: float | None = None, luma_tmp: float | None = None, chroma_tmp: float | None = None)

Apply a High Quality 3D Denoiser.

Parameters:

• luma_spatial (float) – spatial luma strength

• chroma_spatial (float) – spatial chroma strength

• luma_tmp (float) – temporal luma strength

• chroma_tmp (float) – temporal chroma strength

zprp_ffmpeg.generated_filters.hqx(graph: Stream, n: int | None = None)

Scale the input by 2, 3 or 4 using the hq*x magnification algorithm.

Parameters:

n (int) – set scale factor

zprp_ffmpeg.generated_filters.hstack(graph: Stream)

Stack video inputs horizontally.

zprp_ffmpeg.generated_filters.hsvhold(graph: Stream, hue: float | None = None, sat: float | None = None, val: float | None = None, similarity: float | None = None, blend: float | None = None)

Turns a certain HSV range into gray.

Parameters:

• hue (float) – set the hue value

• sat (float) – set the saturation value

• val (float) – set the value value

• similarity (float) – set the hsvhold similarity value

• blend (float) – set the hsvhold blend value

zprp_ffmpeg.generated_filters.hsvkey(graph: Stream, hue: float | None = None, sat: float | None = None, val: float | None = None, similarity: float | None = None, blend: float | None = None)

Turns a certain HSV range into transparency. Operates on YUV colors.

Parameters:

• hue (float) – set the hue value

• sat (float) – set the saturation value

• val (float) – set the value value

• similarity (float) – set the hsvkey similarity value

• blend (float) – set the hsvkey blend value

zprp_ffmpeg.generated_filters.hue(graph: Stream, h: str | None = None, s: str | None = None, H: str | None = None, b: str | None = None)

Adjust the hue and saturation of the input video.

Parameters:

• h (str) – set the hue angle degrees expression

• s (str) – set the saturation expression

• H (str) – set the hue angle radians expression

• b (str) – set the brightness expression

zprp_ffmpeg.generated_filters.huesaturation(graph: Stream, hue: float | None = None, saturation: float | None = None, intensity: float | None = None, colors: str | None = None, strength: float | None = None, rw: float | None = None, gw: float | None = None, bw: float | None = None, lightness: bool | None = None)

Apply hue-saturation-intensity adjustments.

Parameters:

• hue (float) – set the hue shift

• saturation (float) – set the saturation shift

• intensity (float) – set the intensity shift

• colors (str) – set colors range possible values: r, y, g, c, b, m, a

• strength (float) – set the filtering strength

• rw (float) – set the red weight

• gw (float) – set the green weight

• bw (float) – set the blue weight

• lightness (bool) – set the preserve lightness

zprp_ffmpeg.generated_filters.hwdownload(graph: Stream)

Download a hardware frame to a normal frame

zprp_ffmpeg.generated_filters.hwmap(graph: Stream, mode: str | None = None, derive_device: str | None = None, reverse: int | None = None)

Map hardware frames

Parameters:

• mode (str) – Frame mapping mode possible values: read, write, overwrite, direct

• derive_device (str) – Derive a new device of this type

• reverse (int) – Map in reverse (create and allocate in the sink)

zprp_ffmpeg.generated_filters.hwupload(graph: Stream, derive_device: str | None = None)

Upload a normal frame to a hardware frame

Parameters:

derive_device (str) – Derive a new device of this type

zprp_ffmpeg.generated_filters.hwupload_cuda(graph: Stream)

Upload a system memory frame to a CUDA device.

zprp_ffmpeg.generated_filters.hysteresis(graph: Stream, planes: int | None = None, threshold: int | None = None)

Grow first stream into second stream by connecting components.

Parameters:

• planes (int) – set planes

• threshold (int) – set threshold

zprp_ffmpeg.generated_filters.identity(graph: Stream)

Calculate the Identity between two video streams.

zprp_ffmpeg.generated_filters.idet(graph: Stream, intl_thres: float | None = None, prog_thres: float | None = None, rep_thres: float | None = None, half_life: float | None = None, analyze_interlaced_flag: int | None = None)

Interlace detect Filter.

Parameters:

• intl_thres (float) – set interlacing threshold

• prog_thres (float) – set progressive threshold

• rep_thres (float) – set repeat threshold

• half_life (float) – half life of cumulative statistics

• analyze_interlaced_flag (int) – set number of frames to use to determine if the interlace flag is accurate

zprp_ffmpeg.generated_filters.il(graph: Stream, luma_mode: str | None = None, chroma_mode: str | None = None, alpha_mode: str | None = None, luma_swap: bool | None = None, chroma_swap: bool | None = None, alpha_swap: bool | None = None)

Deinterleave or interleave fields.

Parameters:

• luma_mode (str) – select luma mode possible values: none, interleave, i, deinterleave, d

• chroma_mode (str) – select chroma mode possible values: none, interleave, i, deinterleave, d

• alpha_mode (str) – select alpha mode possible values: none, interleave, i, deinterleave, d

• luma_swap (bool) – swap luma fields

• chroma_swap (bool) – swap chroma fields

• alpha_swap (bool) – swap alpha fields

zprp_ffmpeg.generated_filters.inflate(graph: Stream)

Apply inflate effect.

zprp_ffmpeg.generated_filters.interlace(graph: Stream, scan: str | None = None, lowpass: str | None = None)

Convert progressive video into interlaced.

Parameters:

• scan (str) – scanning mode possible values: tff, bff

• lowpass (str) – set vertical low-pass filter possible values: off, linear, complex

zprp_ffmpeg.generated_filters.interleave(graph: Stream, nb_inputs: int | None = None, duration: str | None = None)

Temporally interleave video inputs.

Parameters:

• nb_inputs (int) – set number of inputs

• duration (str) – how to determine the end-of-stream possible values: longest, shortest, first

zprp_ffmpeg.generated_filters.join(graph: Stream, inputs: int | None = None, channel_layout: str | None = None, map: str | None = None)

Join multiple audio streams into multi-channel output.

Parameters:

• inputs (int) – Number of input streams.

• channel_layout (str) – Channel layout of the output stream.

• map (str) – A comma-separated list of channels maps in the format ‘input_stream.input_channel-output_channel.

zprp_ffmpeg.generated_filters.kerndeint(graph: Stream, thresh: int | None = None, map: bool | None = None, order: bool | None = None, sharp: bool | None = None, twoway: bool | None = None)

Apply kernel deinterlacing to the input.

Parameters:

• thresh (int) – set the threshold

• map (bool) – set the map

• order (bool) – set the order

• sharp (bool) – set sharpening

• twoway (bool) – set twoway

zprp_ffmpeg.generated_filters.kirsch(graph: Stream)

Apply kirsch operator.

zprp_ffmpeg.generated_filters.lagfun(graph: Stream, decay: float | None = None, planes: str | None = None)

Slowly update darker pixels.

Parameters:

• decay (float) – set decay

• planes (str) – set what planes to filter

zprp_ffmpeg.generated_filters.latency(graph: Stream)

Report video filtering latency.

zprp_ffmpeg.generated_filters.lenscorrection(graph: Stream, cx: float | None = None, cy: float | None = None, k1: float | None = None, k2: float | None = None, i: str | None = None, fc: str | None = None)

Rectify the image by correcting for lens distortion.

Parameters:

• cx (float) – set relative center x

• cy (float) – set relative center y

• k1 (float) – set quadratic distortion factor

• k2 (float) – set double quadratic distortion factor

• i (str) – set interpolation type possible values: nearest, bilinear

• fc (str) – set the color of the unmapped pixels

zprp_ffmpeg.generated_filters.life(graph: Stream, filename: str | None = None, size: int | None = None, rate: str | None = None, rule: str | None = None, random_fill_ratio: float | None = None, random_seed: int | None = None, stitch: bool | None = None, mold: int | None = None, life_color: str | None = None, death_color: str | None = None, mold_color: str | None = None)

Create life.

Parameters:

• filename (str) – set source file

• size (int) – set video size

• rate (str) – set video rate

• rule (str) – set rule

• random_fill_ratio (float) – set fill ratio for filling initial grid randomly

• random_seed (int) – set the seed for filling the initial grid randomly

• stitch (bool) – stitch boundaries

• mold (int) – set mold speed for dead cells

• life_color (str) – set life color

• death_color (str) – set death color

• mold_color (str) – set mold color

zprp_ffmpeg.generated_filters.limitdiff(graph: Stream, threshold: float | None = None, elasticity: float | None = None, reference: bool | None = None, planes: int | None = None)

Apply filtering with limiting difference.

Parameters:

• threshold (float) – set the threshold

• elasticity (float) – set the elasticity

• reference (bool) – enable reference stream

• planes (int) – set the planes to filter

zprp_ffmpeg.generated_filters.limiter(graph: Stream, min: int | None = None, max: int | None = None, planes: int | None = None)

Limit pixels components to the specified range.

Parameters:

• min (int) – set min value

• max (int) – set max value

• planes (int) – set planes

zprp_ffmpeg.generated_filters.loop(graph: Stream, loop: int | None = None, size: int | None = None, start: int | None = None, time: int | None = None)

Loop video frames.

Parameters:

• loop (int) – number of loops

• size (int) – max number of frames to loop

• start (int) – set the loop start frame

• time (int) – set the loop start time

zprp_ffmpeg.generated_filters.loudnorm(graph: Stream, I: float | None = None, LRA: float | None = None, TP: float | None = None, measured_I: float | None = None, measured_LRA: float | None = None, measured_TP: float | None = None, measured_thresh: float | None = None, offset: float | None = None, linear: bool | None = None, dual_mono: bool | None = None, print_format: str | None = None)

EBU R128 loudness normalization

Parameters:

• I (float) – set integrated loudness target

• LRA (float) – set loudness range target

• TP (float) – set maximum true peak

• measured_I (float) – measured IL of input file

• measured_LRA (float) – measured LRA of input file

• measured_TP (float) – measured true peak of input file

• measured_thresh (float) – measured threshold of input file

• offset (float) – set offset gain

• linear (bool) – normalize linearly if possible

• dual_mono (bool) – treat mono input as dual-mono

• print_format (str) – set print format for stats possible values: none, json, summary

zprp_ffmpeg.generated_filters.lowpass(graph: Stream, frequency: float | None = None, width_type: str | None = None, width: float | None = None, poles: int | None = None, mix: float | None = None, channels: str | None = None, normalize: bool | None = None, transform: str | None = None, precision: str | None = None, blocksize: int | None = None)

Apply a low-pass filter with 3dB point frequency.

Parameters:

• frequency (float) – set frequency

• width_type (str) – set filter-width type possible values: h, q, o, s, k

• width (float) – set width

• poles (int) – set number of poles

• mix (float) – set mix

• channels (str) – set channels to filter

• normalize (bool) – normalize coefficients

• transform (str) – set transform type possible values: di, dii, tdi, tdii, latt, svf, zdf

• precision (str) – set filtering precision possible values: auto, s16, s32, f32, f64

• blocksize (int) – set the block size

zprp_ffmpeg.generated_filters.lowshelf(graph: Stream)

Apply a low shelf filter.

zprp_ffmpeg.generated_filters.lumakey(graph: Stream, threshold: float | None = None, tolerance: float | None = None, softness: float | None = None)

Turns a certain luma into transparency.

Parameters:

• threshold (float) – set the threshold value

• tolerance (float) – set the tolerance value

• softness (float) – set the softness value

zprp_ffmpeg.generated_filters.lut(graph: Stream)

Compute and apply a lookup table to the RGB/YUV input video.

zprp_ffmpeg.generated_filters.lut1d(graph: Stream, file: str | None = None, interp: str | None = None)

Adjust colors using a 1D LUT.

Parameters:

• file (str) – set 1D LUT file name

• interp (str) – select interpolation mode possible values: nearest, linear, cosine, cubic, spline

zprp_ffmpeg.generated_filters.lut2(graph: Stream)

Compute and apply a lookup table from two video inputs.

zprp_ffmpeg.generated_filters.lut3d(graph: Stream)

Adjust colors using a 3D LUT.

zprp_ffmpeg.generated_filters.lutrgb(graph: Stream)

Compute and apply a lookup table to the RGB input video.

zprp_ffmpeg.generated_filters.lutyuv(graph: Stream)

Compute and apply a lookup table to the YUV input video.

zprp_ffmpeg.generated_filters.mandelbrot(graph: Stream, size: int | None = None, rate: str | None = None, maxiter: int | None = None, start_x: float | None = None, start_y: float | None = None, start_scale: float | None = None, end_scale: float | None = None, end_pts: float | None = None, bailout: float | None = None, morphxf: float | None = None, morphyf: float | None = None, morphamp: float | None = None, outer: str | None = None, inner: str | None = None)

Render a Mandelbrot fractal.

Parameters:

• size (int) – set frame size

• rate (str) – set frame rate

• maxiter (int) – set max iterations number

• start_x (float) – set the initial x position

• start_y (float) – set the initial y position

• start_scale (float) – set the initial scale value

• end_scale (float) – set the terminal scale value

• end_pts (float) – set the terminal pts value

• bailout (float) – set the bailout value

• morphxf (float) – set morph x frequency

• morphyf (float) – set morph y frequency

• morphamp (float) – set morph amplitude

• outer (str) – set outer coloring mode possible values: iteration_count, normalized_iteration_count, white, outz

• inner (str) – set inner coloring mode possible values: black, period, convergence, mincol

zprp_ffmpeg.generated_filters.maskedclamp(graph: Stream, undershoot: int | None = None, overshoot: int | None = None, planes: int | None = None)

Clamp first stream with second stream and third stream.

Parameters:

• undershoot (int) – set undershoot

• overshoot (int) – set overshoot

• planes (int) – set planes

zprp_ffmpeg.generated_filters.maskedmax(graph: Stream)

Apply filtering with maximum difference of two streams.

zprp_ffmpeg.generated_filters.maskedmerge(graph: Stream, planes: int | None = None)

Merge first stream with second stream using third stream as mask.

Parameters:

planes (int) – set planes

zprp_ffmpeg.generated_filters.maskedmin(graph: Stream)

Apply filtering with minimum difference of two streams.

zprp_ffmpeg.generated_filters.maskedthreshold(graph: Stream, threshold: int | None = None, planes: int | None = None, mode: str | None = None)

Pick pixels comparing absolute difference of two streams with threshold.

Parameters:

• threshold (int) – set threshold

• planes (int) – set planes

• mode (str) – set mode possible values: abs, diff

zprp_ffmpeg.generated_filters.maskfun(graph: Stream, low: int | None = None, high: int | None = None, planes: int | None = None, fill: int | None = None, sum: int | None = None)

Create Mask.

Parameters:

• low (int) – set low threshold

• high (int) – set high threshold

• planes (int) – set planes

• fill (int) – set fill value

• sum (int) – set sum value

zprp_ffmpeg.generated_filters.mcdeint(graph: Stream, mode: str | None = None, parity: str | None = None, qp: int | None = None)

Apply motion compensating deinterlacing.

Parameters:

• mode (str) – set mode possible values: fast, medium, slow, extra_slow

• parity (str) – set the assumed picture field parity possible values: tff, bff

• qp (int) – set qp

zprp_ffmpeg.generated_filters.mcompand(graph: Stream, args: str | None = None)

Multiband Compress or expand audio dynamic range.

Parameters:

args (str) – set parameters for each band

zprp_ffmpeg.generated_filters.median(graph: Stream, radius: int | None = None, planes: int | None = None, radiusV: int | None = None, percentile: float | None = None)

Apply Median filter.

Parameters:

• radius (int) – set median radius

• planes (int) – set planes to filter

• radiusV (int) – set median vertical radius

• percentile (float) – set median percentile

zprp_ffmpeg.generated_filters.mergeplanes(graph: Stream, mapping: int | None = None, format: str | None = None, map0s: int | None = None, map0p: int | None = None, map1s: int | None = None, map1p: int | None = None, map2s: int | None = None, map2p: int | None = None, map3s: int | None = None, map3p: int | None = None)

Merge planes.

Parameters:

• mapping (int) – set input to output plane mapping

• format (str) – set output pixel format

• map0s (int) – set 1st input to output stream mapping

• map0p (int) – set 1st input to output plane mapping

• map1s (int) – set 2nd input to output stream mapping

• map1p (int) – set 2nd input to output plane mapping

• map2s (int) – set 3rd input to output stream mapping

• map2p (int) – set 3rd input to output plane mapping

• map3s (int) – set 4th input to output stream mapping

• map3p (int) – set 4th input to output plane mapping

zprp_ffmpeg.generated_filters.mestimate(graph: Stream, method: str | None = None, mb_size: int | None = None, search_param: int | None = None)

Generate motion vectors.

Parameters:

• method (str) – motion estimation method possible values: esa, tss, tdls, ntss, fss, ds, hexbs, epzs, umh

• mb_size (int) – macroblock size

• search_param (int) – search parameter

zprp_ffmpeg.generated_filters.metadata(graph: Stream, mode: str | None = None, key: str | None = None, value: str | None = None, function: str | None = None, expr: str | None = None, file: str | None = None, direct: bool | None = None)

Manipulate video frame metadata.

Parameters:

• mode (str) – set a mode of operation possible values: select, add, modify, delete, print

• key (str) – set metadata key

• value (str) – set metadata value

• function (str) – function for comparing values possible values: same_str, starts_with, less, equal, greater, expr, ends_with

• expr (str) – set expression for expr function

• file (str) – set file where to print metadata information

• direct (bool) – reduce buffering when printing to user-set file or pipe

zprp_ffmpeg.generated_filters.midequalizer(graph: Stream, planes: int | None = None)

Apply Midway Equalization.

Parameters:

planes (int) – set planes

zprp_ffmpeg.generated_filters.minterpolate(graph: Stream, fps: str | None = None, mi_mode: str | None = None, mc_mode: str | None = None, me_mode: str | None = None, me: str | None = None, mb_size: int | None = None, search_param: int | None = None, vsbmc: int | None = None, scd: str | None = None, scd_threshold: float | None = None)

Frame rate conversion using Motion Interpolation.

Parameters:

• fps (str) – output’s frame rate

• mi_mode (str) – motion interpolation mode possible values: dup, blend, mci

• mc_mode (str) – motion compensation mode possible values: obmc, aobmc

• me_mode (str) – motion estimation mode possible values: bidir, bilat

• me (str) – motion estimation method possible values: esa, tss, tdls, ntss, fss, ds, hexbs, epzs, umh

• mb_size (int) – macroblock size

• search_param (int) – search parameter

• vsbmc (int) – variable-size block motion compensation

• scd (str) – scene change detection method possible values: none, fdiff

• scd_threshold (float) – scene change threshold

zprp_ffmpeg.generated_filters.mix(graph: Stream, inputs: int | None = None, weights: str | None = None, scale: float | None = None, planes: str | None = None, duration: str | None = None)

Mix video inputs.

Parameters:

• inputs (int) – set number of inputs

• weights (str) – set weight for each input

• scale (float) – set scale

• planes (str) – set what planes to filter

• duration (str) – how to determine end of stream possible values: longest, shortest, first

zprp_ffmpeg.generated_filters.monochrome(graph: Stream, cb: float | None = None, cr: float | None = None, size: float | None = None, high: float | None = None)

Convert video to gray using custom color filter.

Parameters:

• cb (float) – set the chroma blue spot

• cr (float) – set the chroma red spot

• size (float) – set the color filter size

• high (float) – set the highlights strength

zprp_ffmpeg.generated_filters.morpho(graph: Stream, mode: str | None = None, planes: int | None = None, structure: str | None = None)

Apply Morphological filter.

Parameters:

• mode (str) – set morphological transform possible values: erode, dilate, open, close, gradient, tophat, blackhat

• planes (int) – set planes to filter

• structure (str) – when to process structures possible values: first, all

zprp_ffmpeg.generated_filters.mpdecimate(graph: Stream, max: int | None = None, keep: int | None = None, hi: int | None = None, lo: int | None = None, frac: float | None = None)

Remove near-duplicate frames.

Parameters:

• max (int) – set the maximum number of consecutive dropped frames (positive), or the minimum interval between dropped frames (negative)

• keep (int) – set the number of similar consecutive frames to be kept before starting to drop similar frames

• hi (int) – set high dropping threshold

• lo (int) – set low dropping threshold

• frac (float) – set fraction dropping threshold

zprp_ffmpeg.generated_filters.mptestsrc(graph: Stream, rate: str | None = None, duration: int | None = None, test: str | None = None, max_frames: int | None = None)

Generate various test pattern.

Parameters:

• rate (str) – set video rate

• duration (int) – set video duration

• test (str) – set test to perform possible values: dc_luma, dc_chroma, freq_luma, freq_chroma, amp_luma, amp_chroma, cbp, mv, ring1, ring2, all

• max_frames (int) – Set the maximum number of frames generated for each test

zprp_ffmpeg.generated_filters.msad(graph: Stream)

Calculate the MSAD between two video streams.

zprp_ffmpeg.generated_filters.multiply(graph: Stream, scale: float | None = None, offset: float | None = None, planes: str | None = None)

Multiply first video stream with second video stream.

Parameters:

• scale (float) – set scale

• offset (float) – set offset

• planes (str) – set planes

zprp_ffmpeg.generated_filters.negate(graph: Stream, components: str | None = None, negate_alpha: bool | None = None)

Negate input video.

Parameters:

components (str) – set components to negate possible values: y, u, v, r, g, b, a

zprp_ffmpeg.generated_filters.nlmeans(graph: Stream, s: float | None = None, p: int | None = None, pc: int | None = None, r: int | None = None, rc: int | None = None)

Non-local means denoiser.

Parameters:

• s (float) – denoising strength

• p (int) – patch size

• pc (int) – patch size for chroma planes

• r (int) – research window

• rc (int) – research window for chroma planes

zprp_ffmpeg.generated_filters.nlmeans_opencl(graph: Stream, s: float | None = None, p: int | None = None, pc: int | None = None, r: int | None = None, rc: int | None = None)

Non-local means denoiser through OpenCL

Parameters:

• s (float) – denoising strength

• p (int) – patch size

• pc (int) – patch size for chroma planes

• r (int) – research window

• rc (int) – research window for chroma planes

zprp_ffmpeg.generated_filters.nlmeans_vulkan(graph: Stream, s: float | None = None, p: int | None = None, r: int | None = None, t: int | None = None, s1: float | None = None, s2: float | None = None, s3: float | None = None, s4: float | None = None, p1: int | None = None, p2: int | None = None, p3: int | None = None, p4: int | None = None)

Non-local means denoiser (Vulkan)

Parameters:

• s (float) – denoising strength for all components

• p (int) – patch size for all components

• r (int) – research window radius

• t (int) – parallelism

• s1 (float) – denoising strength for component 1

• s2 (float) – denoising strength for component 2

• s3 (float) – denoising strength for component 3

• s4 (float) – denoising strength for component 4

• p1 (int) – patch size for component 1

• p2 (int) – patch size for component 2

• p3 (int) – patch size for component 3

• p4 (int) – patch size for component 4

zprp_ffmpeg.generated_filters.nnedi(graph: Stream, weights: str | None = None, deint: str | None = None, field: str | None = None, planes: int | None = None, nsize: str | None = None, nns: str | None = None, qual: str | None = None, etype: str | None = None, pscrn: str | None = None)

Apply neural network edge directed interpolation intra-only deinterlacer.

Parameters:

• weights (str) – set weights file

• deint (str) – set which frames to deinterlace possible values: all, interlaced

• field (str) – set mode of operation possible values: af, a, t, b, tf, bf

• planes (int) – set which planes to process

• nsize (str) – set size of local neighborhood around each pixel, used by the predictor neural network possible values: s8x6, s16x6, s32x6, s48x6, s8x4, s16x4, s32x4

• nns (str) – set number of neurons in predictor neural network possible values: n16, n32, n64, n128, n256

• qual (str) – set quality possible values: fast, slow

• etype (str) – set which set of weights to use in the predictor possible values: a, abs, s, mse

• pscrn (str) – set prescreening possible values: none, original, new, new2, new3

zprp_ffmpeg.generated_filters.noformat(graph: Stream)

Force libavfilter not to use any of the specified pixel formats for the input to the next filter.

zprp_ffmpeg.generated_filters.noise(graph: Stream, all_seed: int | None = None, all_strength: int | None = None, alls: int | None = None, all_flags: str | None = None, allf: str | None = None, c0_seed: int | None = None, c0_strength: int | None = None, c0s: int | None = None, c0_flags: str | None = None, c0f: str | None = None, c1_seed: int | None = None, c1_strength: int | None = None, c1s: int | None = None, c1_flags: str | None = None, c1f: str | None = None, c2_seed: int | None = None, c2_strength: int | None = None, c2s: int | None = None, c2_flags: str | None = None, c2f: str | None = None, c3_seed: int | None = None, c3_strength: int | None = None, c3s: int | None = None, c3_flags: str | None = None, c3f: str | None = None)

Add noise.

Parameters:

• all_seed (int) – set component #0 noise seed

• all_strength (int) – set component #0 strength

• alls (int) – set component #0 strength

• all_flags (str) – set component #0 flags possible values: a, p, t, u

• allf (str) – set component #0 flags possible values: a, p, t, u

• c0_seed (int) – set component #0 noise seed

• c0_strength (int) – set component #0 strength

• c0s (int) – set component #0 strength

• c0_flags (str) – set component #0 flags possible values: a, p, t, u

• c0f (str) – set component #0 flags possible values: a, p, t, u

• c1_seed (int) – set component #1 noise seed

• c1_strength (int) – set component #1 strength

• c1s (int) – set component #1 strength

• c1_flags (str) – set component #1 flags possible values: a, p, t, u

• c1f (str) – set component #1 flags possible values: a, p, t, u

• c2_seed (int) – set component #2 noise seed

• c2_strength (int) – set component #2 strength

• c2s (int) – set component #2 strength

• c2_flags (str) – set component #2 flags possible values: a, p, t, u

• c2f (str) – set component #2 flags possible values: a, p, t, u

• c3_seed (int) – set component #3 noise seed

• c3_strength (int) – set component #3 strength

• c3s (int) – set component #3 strength

• c3_flags (str) – set component #3 flags possible values: a, p, t, u

• c3f (str) – set component #3 flags possible values: a, p, t, u

zprp_ffmpeg.generated_filters.normalize(graph: Stream, blackpt: str | None = None, whitept: str | None = None, smoothing: int | None = None, independence: float | None = None, strength: float | None = None)

Normalize RGB video. :param str blackpt: output color to which darkest input color is mapped

Parameters:

• whitept (str) – output color to which brightest input color is mapped

• smoothing (int) – amount of temporal smoothing of the input range, to reduce flicker

• independence (float) – proportion of independent to linked channel normalization

• strength (float) – strength of filter, from no effect to full normalization

zprp_ffmpeg.generated_filters.null(graph: Stream)

Pass the source unchanged to the output.

zprp_ffmpeg.generated_filters.nullsrc(graph: Stream)

Null video source, return unprocessed video frames.

zprp_ffmpeg.generated_filters.oscilloscope(graph: Stream, x: float | None = None, y: float | None = None, s: float | None = None, t: float | None = None, o: float | None = None, tx: float | None = None, ty: float | None = None, tw: float | None = None, th: float | None = None, c: int | None = None, g: bool | None = None, st: bool | None = None, sc: bool | None = None)

2D Video Oscilloscope.

Parameters:

• x (float) – set scope x position

• y (float) – set scope y position

• s (float) – set scope size

• t (float) – set scope tilt

• o (float) – set trace opacity

• tx (float) – set trace x position

• ty (float) – set trace y position

• tw (float) – set trace width

• th (float) – set trace height

• c (int) – set components to trace

• g (bool) – draw trace grid

• st (bool) – draw statistics

• sc (bool) – draw scope

zprp_ffmpeg.generated_filters.overlay_opencl(graph: Stream, x: int | None = None, y: int | None = None)

Overlay one video on top of another

Parameters:

• x (int) – Overlay x position

• y (int) – Overlay y position

zprp_ffmpeg.generated_filters.overlay_vulkan(graph: Stream, x: int | None = None, y: int | None = None)

Overlay a source on top of another

Parameters:

• x (int) – Set horizontal offset

• y (int) – Set vertical offset

zprp_ffmpeg.generated_filters.owdenoise(graph: Stream, depth: int | None = None, luma_strength: float | None = None, chroma_strength: float | None = None)

Denoise using wavelets.

Parameters:

• depth (int) – set depth

• luma_strength (float) – set luma strength

• chroma_strength (float) – set chroma strength

zprp_ffmpeg.generated_filters.pad(graph: Stream, width: str | None = None, height: str | None = None, x: str | None = None, y: str | None = None, color: str | None = None, eval: str | None = None, aspect: int | None = None)

Pad the input video.

Parameters:

• width (str) – set the pad area width expression

• height (str) – set the pad area height expression

• x (str) – set the x offset expression for the input image position

• y (str) – set the y offset expression for the input image position

• color (str) – set the color of the padded area border

• eval (str) – specify when to evaluate expressions possible values: init, frame

• aspect (int) – pad to fit an aspect instead of a resolution

zprp_ffmpeg.generated_filters.pad_opencl(graph: Stream, width: str | None = None, height: str | None = None, x: str | None = None, y: str | None = None, color: str | None = None, aspect: int | None = None)

Pad the input video.

Parameters:

• width (str) – set the pad area width

• height (str) – set the pad area height

• x (str) – set the x offset for the input image position

• y (str) – set the y offset for the input image position

• color (str) – set the color of the padded area border

• aspect (int) – pad to fit an aspect instead of a resolution

zprp_ffmpeg.generated_filters.pad_vaapi(graph: Stream, width: str | None = None, height: str | None = None, x: str | None = None, y: str | None = None, color: str | None = None, aspect: int | None = None)

Pad the input video.

Parameters:

• width (str) – set the pad area width

• height (str) – set the pad area height

• x (str) – set the x offset for the input image position

• y (str) – set the y offset for the input image position

• color (str) – set the color of the padded area border

• aspect (int) – pad to fit an aspect instead of a resolution

zprp_ffmpeg.generated_filters.pal100bars(graph: Stream)

Generate PAL 100% color bars.

zprp_ffmpeg.generated_filters.pal75bars(graph: Stream)

Generate PAL 75% color bars.

zprp_ffmpeg.generated_filters.palettegen(graph: Stream, max_colors: int | None = None, reserve_transparent: bool | None = None, transparency_color: str | None = None, stats_mode: str | None = None)

Find the optimal palette for a given stream.

Parameters:

• max_colors (int) – set the maximum number of colors to use in the palette

• reserve_transparent (bool) – reserve a palette entry for transparency

• transparency_color (str) – set a background color for transparency

• stats_mode (str) – set statistics mode possible values: full, diff, single

zprp_ffmpeg.generated_filters.paletteuse(graph: Stream, dither: str | None = None, bayer_scale: int | None = None, diff_mode: str | None = None, new: bool | None = None, alpha_threshold: int | None = None, debug_kdtree: str | None = None)

Use a palette to downsample an input video stream.

Parameters:

• dither (str) – select dithering mode possible values: bayer, heckbert, floyd_steinberg, sierra2, sierra2_4a, sierra3, burkes, atkinson

• bayer_scale (int) – set scale for bayer dithering

• diff_mode (str) – set frame difference mode possible values: rectangle

• new (bool) – take new palette for each output frame

• alpha_threshold (int) – set the alpha threshold for transparency

• debug_kdtree (str) – save Graphviz graph of the kdtree in specified file

zprp_ffmpeg.generated_filters.pan(graph: Stream, args: str | None = None)

Remix channels with coefficients (panning).

zprp_ffmpeg.generated_filters.perms(graph: Stream)

Set permissions for the output video frame.

zprp_ffmpeg.generated_filters.perspective(graph: Stream, x0: str | None = None, y0: str | None = None, x1: str | None = None, y1: str | None = None, x2: str | None = None, y2: str | None = None, x3: str | None = None, y3: str | None = None, interpolation: str | None = None, sense: str | None = None, eval: str | None = None)

Correct the perspective of video.

Parameters:

• x0 (str) – set top left x coordinate

• y0 (str) – set top left y coordinate

• x1 (str) – set top right x coordinate

• y1 (str) – set top right y coordinate

• x2 (str) – set bottom left x coordinate

• y2 (str) – set bottom left y coordinate

• x3 (str) – set bottom right x coordinate

• y3 (str) – set bottom right y coordinate

• interpolation (str) – set interpolation possible values: linear, cubic

• sense (str) – specify the sense of the coordinates possible values: source, destination

• eval (str) – specify when to evaluate expressions possible values: init, frame

zprp_ffmpeg.generated_filters.phase(graph: Stream, mode: str | None = None)

Phase shift fields.

Parameters:

mode (str) – set phase mode possible values: p, t, b, T, B, u, U, a, A

zprp_ffmpeg.generated_filters.photosensitivity(graph: Stream, frames: int | None = None, threshold: float | None = None, skip: int | None = None, bypass: bool | None = None)

Filter out photosensitive epilepsy seizure-inducing flashes.

Parameters:

• frames (int) – set how many frames to use

• threshold (float) – set detection threshold factor (lower is stricter)

• skip (int) – set pixels to skip when sampling frames

• bypass (bool) – leave frames unchanged

zprp_ffmpeg.generated_filters.pixdesctest(graph: Stream)

Test pixel format definitions.

zprp_ffmpeg.generated_filters.pixelize(graph: Stream, width: int | None = None, w: int | None = None, height: int | None = None, h: int | None = None, mode: str | None = None, planes: str | None = None)

Pixelize video.

Parameters:

• width (int) – set block width

• w (int) – set block width

• height (int) – set block height

• h (int) – set block height

• mode (str) – set the pixelize mode possible values: avg, min, max

• planes (str) – set what planes to filter

zprp_ffmpeg.generated_filters.pixscope(graph: Stream, x: float | None = None, y: float | None = None, w: int | None = None, h: int | None = None, o: float | None = None, wx: float | None = None, wy: float | None = None)

Pixel data analysis.

Parameters:

• x (float) – set scope x offset

• y (float) – set scope y offset

• w (int) – set scope width

• h (int) – set scope height

• o (float) – set window opacity

• wx (float) – set window x offset

• wy (float) – set window y offset

zprp_ffmpeg.generated_filters.pp(graph: Stream, subfilters: str | None = None)

Filter video using libpostproc.

Parameters:

subfilters (str) – set postprocess subfilters

zprp_ffmpeg.generated_filters.pp7(graph: Stream, qp: int | None = None, mode: str | None = None)

Apply Postprocessing 7 filter.

Parameters:

• qp (int) – force a constant quantizer parameter

• mode (str) – set thresholding mode possible values: hard, soft, medium

zprp_ffmpeg.generated_filters.premultiply(graph: Stream)

PreMultiply first stream with first plane of second stream.

zprp_ffmpeg.generated_filters.prewitt(graph: Stream)

Apply prewitt operator.

zprp_ffmpeg.generated_filters.pseudocolor(graph: Stream, c0: str | None = None, c1: str | None = None, c2: str | None = None, c3: str | None = None, index: int | None = None, preset: str | None = None, opacity: float | None = None)

Make pseudocolored video frames.

Parameters:

• c0 (str) – set component #0 expression

• c1 (str) – set component #1 expression

• c2 (str) – set component #2 expression

• c3 (str) – set component #3 expression

• index (int) – set component as base

• preset (str) – set preset possible values: none, magma, inferno, plasma, viridis, turbo, cividis, range1, range2, shadows, highlights, solar, nominal, preferred, total, spectral, cool, heat, fiery, blues, green, helix

• opacity (float) – set pseudocolor opacity

zprp_ffmpeg.generated_filters.psnr(graph: Stream, stats_file: str | None = None, stats_version: int | None = None, output_max: bool | None = None)

Calculate the PSNR between two video streams.

Parameters:

• stats_file (str) – Set file where to store per-frame difference information

• stats_version (int) – Set the format version for the stats file.

• output_max (bool) – Add raw stats (max values) to the output log.

zprp_ffmpeg.generated_filters.pullup(graph: Stream, jl: int | None = None, jr: int | None = None, jt: int | None = None, jb: int | None = None, sb: bool | None = None, mp: str | None = None)

Pullup from field sequence to frames.

Parameters:

• jl (int) – set left junk size

• jr (int) – set right junk size

• jt (int) – set top junk size

• jb (int) – set bottom junk size

• sb (bool) – set strict breaks

• mp (str) – set metric plane possible values: y, u, v

zprp_ffmpeg.generated_filters.qp(graph: Stream, qp: str | None = None)

Change video quantization parameters.

Parameters:

qp (str) – set qp expression

zprp_ffmpeg.generated_filters.random(graph: Stream, frames: int | None = None, seed: int | None = None)

Return random frames.

Parameters:

• frames (int) – set number of frames in cache

• seed (int) – set the seed

zprp_ffmpeg.generated_filters.readeia608(graph: Stream, scan_min: int | None = None, scan_max: int | None = None, spw: float | None = None, chp: bool | None = None, lp: bool | None = None)

Read EIA-608 Closed Caption codes from input video and write them to frame metadata.

Parameters:

• scan_min (int) – set from which line to scan for codes

• scan_max (int) – set to which line to scan for codes

• spw (float) – set ratio of width reserved for sync code detection

• chp (bool) – check and apply parity bit

• lp (bool) – lowpass line prior to processing

zprp_ffmpeg.generated_filters.readvitc(graph: Stream, scan_max: int | None = None, thr_b: float | None = None, thr_w: float | None = None)

Read vertical interval timecode and write it to frame metadata.

Parameters:

• scan_max (int) – maximum line numbers to scan for VITC data

• thr_b (float) – black color threshold

• thr_w (float) – white color threshold

zprp_ffmpeg.generated_filters.realtime(graph: Stream)

Slow down filtering to match realtime.

zprp_ffmpeg.generated_filters.remap(graph: Stream, format: str | None = None, fill: str | None = None)

Remap pixels.

Parameters:

• format (str) – set output format possible values: color, gray

• fill (str) – set the color of the unmapped pixels

zprp_ffmpeg.generated_filters.remap_opencl(graph: Stream, interp: str | None = None, fill: str | None = None)

Remap pixels using OpenCL.

Parameters:

• interp (str) – set interpolation method possible values: near, linear

• fill (str) – set the color of the unmapped pixels

zprp_ffmpeg.generated_filters.removegrain(graph: Stream, m0: int | None = None, m1: int | None = None, m2: int | None = None, m3: int | None = None)

Remove grain.

Parameters:

• m0 (int) – set mode for 1st plane

• m1 (int) – set mode for 2nd plane

• m2 (int) – set mode for 3rd plane

• m3 (int) – set mode for 4th plane

zprp_ffmpeg.generated_filters.removelogo(graph: Stream, filename: str | None = None)

Remove a TV logo based on a mask image.

Parameters:

filename (str) – set bitmap filename

zprp_ffmpeg.generated_filters.repeatfields(graph: Stream)

Hard repeat fields based on MPEG repeat field flag.

zprp_ffmpeg.generated_filters.replaygain(graph: Stream, track_gain: float | None = None, track_peak: float | None = None)

ReplayGain scanner.

Parameters:

• track_gain (float) – track gain (dB)

• track_peak (float) – track peak

zprp_ffmpeg.generated_filters.reverse(graph: Stream)

Reverse a clip.

zprp_ffmpeg.generated_filters.rgbashift(graph: Stream, rh: int | None = None, rv: int | None = None, gh: int | None = None, gv: int | None = None, bh: int | None = None, bv: int | None = None, ah: int | None = None, av: int | None = None, edge: str | None = None)

Shift RGBA.

Parameters:

• rh (int) – shift red horizontally

• rv (int) – shift red vertically

• gh (int) – shift green horizontally

• gv (int) – shift green vertically

• bh (int) – shift blue horizontally

• bv (int) – shift blue vertically

• ah (int) – shift alpha horizontally

• av (int) – shift alpha vertically

• edge (str) – set edge operation possible values: smear, wrap

zprp_ffmpeg.generated_filters.rgbtestsrc(graph: Stream, size: int | None = None, rate: str | None = None, duration: int | None = None, sar: int | None = None, complement: bool | None = None)

Generate RGB test pattern.

Parameters:

• size (int) – set video size

• rate (str) – set video rate

• duration (int) – set video duration

• sar (int) – set video sample aspect ratio

• complement (bool) – set complement colors

zprp_ffmpeg.generated_filters.roberts(graph: Stream)

Apply roberts cross operator.

zprp_ffmpeg.generated_filters.rotate(graph: Stream, angle: str | None = None, out_w: str | None = None, out_h: str | None = None, fillcolor: str | None = None, bilinear: bool | None = None)

Rotate the input image.

Parameters:

• angle (str) – set angle (in radians)

• out_w (str) – set output width expression

• out_h (str) – set output height expression

• fillcolor (str) – set background fill color

• bilinear (bool) – use bilinear interpolation

zprp_ffmpeg.generated_filters.sab(graph: Stream, luma_radius: float | None = None, lr: float | None = None, luma_pre_filter_radius: float | None = None, lpfr: float | None = None, luma_strength: float | None = None, ls: float | None = None, chroma_radius: float | None = None, cr: float | None = None, chroma_pre_filter_radius: float | None = None, cpfr: float | None = None, chroma_strength: float | None = None, cs: float | None = None)

Apply shape adaptive blur.

Parameters:

• luma_radius (float) – set luma radius

• lr (float) – set luma radius

• luma_pre_filter_radius (float) – set luma pre-filter radius

• lpfr (float) – set luma pre-filter radius

• luma_strength (float) – set luma strength

• ls (float) – set luma strength

• chroma_radius (float) – set chroma radius

• cr (float) – set chroma radius

• chroma_pre_filter_radius (float) – set chroma pre-filter radius

• cpfr (float) – set chroma pre-filter radius

• chroma_strength (float) – set chroma strength

• cs (float) – set chroma strength

zprp_ffmpeg.generated_filters.scale(graph: Stream, w: str | None = None, h: str | None = None, flags: str | None = None, interl: bool | None = None, size: str | None = None, in_color_matrix: str | None = None, out_color_matrix: str | None = None, in_range: str | None = None, out_range: str | None = None, in_v_chr_pos: int | None = None, in_h_chr_pos: int | None = None, out_v_chr_pos: int | None = None, out_h_chr_pos: int | None = None, force_original_aspect_ratio: str | None = None, force_divisible_by: int | None = None, param0: float | None = None, param1: float | None = None, eval: str | None = None)

Scale the input video size and/or convert the image format.

Parameters:

• w (str) – Output video width

• h (str) – Output video height

• flags (str) – Flags to pass to libswscale

• interl (bool) – set interlacing

• size (str) – set video size

• in_color_matrix (str) – set input YCbCr type possible values: auto, bt601, bt470, smpte170m, bt709, fcc, smpte240m, bt2020

• out_color_matrix (str) – set output YCbCr type possible values: auto, bt601, bt470, smpte170m, bt709, fcc, smpte240m, bt2020

• in_range (str) – set input color range possible values: auto, unknown, full, limited, jpeg, mpeg, tv, pc

• out_range (str) – set output color range possible values: auto, unknown, full, limited, jpeg, mpeg, tv, pc

• in_v_chr_pos (int) – input vertical chroma position in luma grid/256

• in_h_chr_pos (int) – input horizontal chroma position in luma grid/256

• out_v_chr_pos (int) – output vertical chroma position in luma grid/256

• out_h_chr_pos (int) – output horizontal chroma position in luma grid/256

• force_original_aspect_ratio (str) – decrease or increase w/h if necessary to keep the original AR possible values: disable, decrease, increase

• force_divisible_by (int) – enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used

• param0 (float) – Scaler param 0

• param1 (float) – Scaler param 1

• eval (str) – specify when to evaluate expressions possible values: init, frame

zprp_ffmpeg.generated_filters.scale2ref(graph: Stream)

Scale the input video size and/or convert the image format to the given reference.

zprp_ffmpeg.generated_filters.scale_vaapi(graph: Stream, w: str | None = None, h: str | None = None, format: str | None = None, mode: str | None = None, out_color_matrix: str | None = None, out_range: str | None = None, out_color_primaries: str | None = None, out_color_transfer: str | None = None, out_chroma_location: str | None = None, force_original_aspect_ratio: str | None = None, force_divisible_by: int | None = None)

Scale to/from VAAPI surfaces.

Parameters:

• w (str) – Output video width

• h (str) – Output video height

• format (str) – Output video format (software format of hardware frames)

• mode (str) – Scaling mode possible values: default, fast, hq, nl_anamorphic

• out_color_matrix (str) – Output colour matrix coefficient set

• out_range (str) – Output colour range possible values: full, limited, jpeg, mpeg, tv, pc

• out_color_primaries (str) – Output colour primaries

• out_color_transfer (str) – Output colour transfer characteristics

• out_chroma_location (str) – Output chroma sample location

• force_original_aspect_ratio (str) – decrease or increase w/h if necessary to keep the original AR possible values: disable, decrease, increase

• force_divisible_by (int) – enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used

zprp_ffmpeg.generated_filters.scale_vulkan(graph: Stream, w: str | None = None, h: str | None = None, scaler: str | None = None, format: str | None = None, out_range: str | None = None)

Scale Vulkan frames

Parameters:

• w (str) – Output video width

• h (str) – Output video height

• scaler (str) – Scaler function possible values: bilinear, nearest

• format (str) – Output video format (software format of hardware frames)

• out_range (str) – Output colour range (from 0 to 2) (default 0) possible values: full, limited, jpeg, mpeg, tv, pc

zprp_ffmpeg.generated_filters.scdet(graph: Stream, threshold: float | None = None, sc_pass: bool | None = None)

Detect video scene change

Parameters:

• threshold (float) – set scene change detect threshold

• sc_pass (bool) – Set the flag to pass scene change frames

zprp_ffmpeg.generated_filters.scharr(graph: Stream)

Apply scharr operator.

zprp_ffmpeg.generated_filters.scroll(graph: Stream, horizontal: float | None = None, vertical: float | None = None, hpos: float | None = None, vpos: float | None = None)

Scroll input video.

Parameters:

• horizontal (float) – set the horizontal scrolling speed

• vertical (float) – set the vertical scrolling speed

• hpos (float) – set initial horizontal position

• vpos (float) – set initial vertical position

zprp_ffmpeg.generated_filters.selectivecolor(graph: Stream, correction_method: str | None = None, reds: str | None = None, yellows: str | None = None, greens: str | None = None, cyans: str | None = None, blues: str | None = None, magentas: str | None = None, whites: str | None = None, neutrals: str | None = None, blacks: str | None = None, psfile: str | None = None)

Apply CMYK adjustments to specific color ranges.

Parameters:

• correction_method (str) – select correction method possible values: absolute, relative

• reds (str) – adjust red regions

• yellows (str) – adjust yellow regions

• greens (str) – adjust green regions

• cyans (str) – adjust cyan regions

• blues (str) – adjust blue regions

• magentas (str) – adjust magenta regions

• whites (str) – adjust white regions

• neutrals (str) – adjust neutral regions

• blacks (str) – adjust black regions

• psfile (str) – set Photoshop selectivecolor file name

zprp_ffmpeg.generated_filters.sendcmd(graph: Stream)

Send commands to filters.

zprp_ffmpeg.generated_filters.separatefields(graph: Stream)

Split input video frames into fields.

zprp_ffmpeg.generated_filters.setdar(graph: Stream, dar: str | None = None, max: int | None = None)

Set the frame display aspect ratio.

Parameters:

• dar (str) – set display aspect ratio

• max (int) – set max value for nominator or denominator in the ratio

zprp_ffmpeg.generated_filters.setfield(graph: Stream, mode: str | None = None)

Force field for the output video frame.

Parameters:

mode (str) – select interlace mode possible values: auto, bff, tff, prog

zprp_ffmpeg.generated_filters.setparams(graph: Stream, field_mode: str | None = None, range: str | None = None, color_primaries: str | None = None, color_trc: str | None = None, colorspace: str | None = None)

Force field, or color property for the output video frame.

Parameters:

• field_mode (str) – select interlace mode possible values: auto, bff, tff, prog

• range (str) – select color range possible values: auto, unspecified, unknown, limited, tv, mpeg, full, pc, jpeg

• color_primaries (str) – select color primaries possible values: auto, bt709, unknown, bt470m, bt470bg, smpte170m, smpte240m, film, bt2020, smpte428, smpte431, smpte432, jedec-p22, ebu3213

• color_trc (str) – select color transfer possible values: auto, bt709, unknown, bt470m, bt470bg, smpte170m, smpte240m, linear, log100, log316, iec61966-2-4, bt1361e, iec61966-2-1, bt2020-10, bt2020-12, smpte2084, smpte428, arib-std-b67

• colorspace (str) – select colorspace possible values: auto, gbr, bt709, unknown, fcc, bt470bg, smpte170m, smpte240m, ycgco, ycgco-re, ycgco-ro, bt2020nc, bt2020c, smpte2085, chroma-derived-nc, chroma-derived-c, ictcp, ipt-c2

zprp_ffmpeg.generated_filters.setpts(graph: Stream, expr: str | None = None)

Set PTS for the output video frame.

Parameters:

expr (str) – Expression determining the frame timestamp

zprp_ffmpeg.generated_filters.setrange(graph: Stream, range: str | None = None)

Force color range for the output video frame.

Parameters:

range (str) – select color range possible values: auto, unspecified, unknown, limited, tv, mpeg, full, pc, jpeg

zprp_ffmpeg.generated_filters.setsar(graph: Stream, sar: str | None = None, max: int | None = None)

Set the pixel sample aspect ratio.

Parameters:

• sar (str) – set sample (pixel) aspect ratio

• max (int) – set max value for nominator or denominator in the ratio

zprp_ffmpeg.generated_filters.settb(graph: Stream, expr: str | None = None)

Set timebase for the video output link.

Parameters:

expr (str) – set expression determining the output timebase

zprp_ffmpeg.generated_filters.shear(graph: Stream, shx: float | None = None, shy: float | None = None, fillcolor: str | None = None, interp: str | None = None)

Shear transform the input image.

Parameters:

• shx (float) – set x shear factor

• shy (float) – set y shear factor

• fillcolor (str) – set background fill color

• interp (str) – set interpolation possible values: nearest, bilinear

zprp_ffmpeg.generated_filters.showcqt(graph: Stream, size: int | None = None, fps: str | None = None, bar_h: int | None = None, axis_h: int | None = None, sono_h: int | None = None, fullhd: bool | None = None, sono_v: str | None = None, bar_v: str | None = None, sono_g: float | None = None, bar_g: float | None = None, bar_t: float | None = None, timeclamp: float | None = None, attack: float | None = None, basefreq: float | None = None, endfreq: float | None = None, coeffclamp: float | None = None, tlength: str | None = None, count: int | None = None, fcount: int | None = None, fontfile: str | None = None, font: str | None = None, fontcolor: str | None = None, axisfile: str | None = None, axis: bool | None = None, csp: str | None = None, cscheme: str | None = None)

Convert input audio to a CQT (Constant/Clamped Q Transform) spectrum video output.

Parameters:

• size (int) – set video size

• fps (str) – set video rate

• bar_h (int) – set bargraph height

• axis_h (int) – set axis height

• sono_h (int) – set sonogram height

• fullhd (bool) – set fullhd size

• sono_v (str) – set sonogram volume

• bar_v (str) – set bargraph volume

• sono_g (float) – set sonogram gamma

• bar_g (float) – set bargraph gamma

• bar_t (float) – set bar transparency

• timeclamp (float) – set timeclamp

• attack (float) – set attack time

• basefreq (float) – set base frequency

• endfreq (float) – set end frequency

• coeffclamp (float) – set coeffclamp

• tlength (str) – set tlength

• count (int) – set transform count

• fcount (int) – set frequency count

• fontfile (str) – set axis font file

• font (str) – set axis font

• fontcolor (str) – set font color

• axisfile (str) – set axis image

• axis (bool) – draw axis

• csp (str) – set color space possible values: unspecified, bt709, fcc, bt470bg, smpte170m, smpte240m, bt2020ncl

• cscheme (str) – set color scheme

zprp_ffmpeg.generated_filters.showcwt(graph: Stream, size: int | None = None, rate: str | None = None, scale: str | None = None, iscale: str | None = None, min: float | None = None, max: float | None = None, imin: float | None = None, imax: float | None = None, logb: float | None = None, deviation: float | None = None, pps: int | None = None, mode: str | None = None, slide: str | None = None, direction: str | None = None, bar: float | None = None, rotation: float | None = None)

Convert input audio to a CWT (Continuous Wavelet Transform) spectrum video output.

Parameters:

• size (int) – set video size

• rate (str) – set video rate

• scale (str) – set frequency scale possible values: linear, log, bark, mel, erbs, sqrt, cbrt, qdrt, fm

• iscale (str) – set intensity scale possible values: linear, log, sqrt, cbrt, qdrt

• min (float) – set minimum frequency

• max (float) – set maximum frequency

• imin (float) – set minimum intensity

• imax (float) – set maximum intensity

• logb (float) – set logarithmic basis

• deviation (float) – set frequency deviation

• pps (int) – set pixels per second

• mode (str) – set output mode possible values: magnitude, phase, magphase, channel, stereo

• slide (str) – set slide mode possible values: replace, scroll, frame

• direction (str) – set direction mode possible values: lr, rl, ud, du

• bar (float) – set bargraph ratio

• rotation (float) – set color rotation

zprp_ffmpeg.generated_filters.showfreqs(graph: Stream, size: int | None = None, rate: str | None = None, mode: str | None = None, ascale: str | None = None, fscale: str | None = None, win_size: int | None = None, win_func: str | None = None, overlap: float | None = None, averaging: int | None = None, colors: str | None = None, cmode: str | None = None, minamp: float | None = None, data: str | None = None, channels: str | None = None)

Convert input audio to a frequencies video output.

Parameters:

• size (int) – set video size

• rate (str) – set video rate

• mode (str) – set display mode possible values: line, bar, dot

• ascale (str) – set amplitude scale possible values: lin, sqrt, cbrt, log

• fscale (str) – set frequency scale possible values: lin, log, rlog

• win_size (int) – set window size

• win_func (str) – set window function possible values: rect, bartlett, hann, hanning, hamming, blackman, welch, flattop, bharris, bnuttall, bhann, sine, nuttall, lanczos, gauss, tukey, dolph, cauchy, parzen, poisson, bohman, kaiser

• overlap (float) – set window overlap

• averaging (int) – set time averaging

• colors (str) – set channels colors

• cmode (str) – set channel mode possible values: combined, separate

• minamp (float) – set minimum amplitude

• data (str) – set data mode possible values: magnitude, phase, delay

• channels (str) – set channels to draw

zprp_ffmpeg.generated_filters.showinfo(graph: Stream, checksum: bool | None = None, udu_sei_as_ascii: bool | None = None)

Show textual information for each video frame.

Parameters:

• checksum (bool) – calculate checksums

• udu_sei_as_ascii (bool) – try to print user data unregistered SEI as ascii character when possible

zprp_ffmpeg.generated_filters.showpalette(graph: Stream, s: int | None = None)

Display frame palette.

Parameters:

s (int) – set pixel box size

zprp_ffmpeg.generated_filters.showspatial(graph: Stream, size: int | None = None, win_size: int | None = None, win_func: str | None = None, rate: str | None = None)

Convert input audio to a spatial video output.

Parameters:

• size (int) – set video size

• win_size (int) – set window size

• win_func (str) – set window function possible values: rect, bartlett, hann, hanning, hamming, blackman, welch, flattop, bharris, bnuttall, bhann, sine, nuttall, lanczos, gauss, tukey, dolph, cauchy, parzen, poisson, bohman, kaiser

• rate (str) – set video rate

zprp_ffmpeg.generated_filters.showspectrum(graph: Stream, size: int | None = None, slide: str | None = None, mode: str | None = None, color: str | None = None, scale: str | None = None, fscale: str | None = None, saturation: float | None = None, win_func: str | None = None, orientation: str | None = None, overlap: float | None = None, gain: float | None = None, data: str | None = None, rotation: float | None = None, start: int | None = None, stop: int | None = None, fps: str | None = None, legend: bool | None = None, drange: float | None = None, limit: float | None = None, opacity: float | None = None)

Convert input audio to a spectrum video output.

Parameters:

• size (int) – set video size

• slide (str) – set sliding mode possible values: replace, scroll, fullframe, rscroll, lreplace

• mode (str) – set channel display mode possible values: combined, separate

• color (str) – set channel coloring possible values: channel, intensity, rainbow, moreland, nebulae, fire, fiery, fruit, cool, magma, green, viridis, plasma, cividis, terrain

• scale (str) – set display scale possible values: lin, sqrt, cbrt, log, 4thrt, 5thrt

• fscale (str) – set frequency scale possible values: lin, log

• saturation (float) – color saturation multiplier

• win_func (str) – set window function possible values: rect, bartlett, hann, hanning, hamming, blackman, welch, flattop, bharris, bnuttall, bhann, sine, nuttall, lanczos, gauss, tukey, dolph, cauchy, parzen, poisson, bohman, kaiser

• orientation (str) – set orientation possible values: vertical, horizontal

• overlap (float) – set window overlap

• gain (float) – set scale gain

• data (str) – set data mode possible values: magnitude, phase, uphase

• rotation (float) – color rotation

• start (int) – start frequency

• stop (int) – stop frequency

• fps (str) – set video rate

• legend (bool) – draw legend

• drange (float) – set dynamic range in dBFS

• limit (float) – set upper limit in dBFS

• opacity (float) – set opacity strength

zprp_ffmpeg.generated_filters.showspectrumpic(graph: Stream, size: int | None = None, mode: str | None = None, color: str | None = None, scale: str | None = None, fscale: str | None = None, saturation: float | None = None, win_func: str | None = None, orientation: str | None = None, gain: float | None = None, legend: bool | None = None, rotation: float | None = None, start: int | None = None, stop: int | None = None, drange: float | None = None, limit: float | None = None, opacity: float | None = None)

Convert input audio to a spectrum video output single picture.

Parameters:

• size (int) – set video size

• mode (str) – set channel display mode possible values: combined, separate

• color (str) – set channel coloring possible values: channel, intensity, rainbow, moreland, nebulae, fire, fiery, fruit, cool, magma, green, viridis, plasma, cividis, terrain

• scale (str) – set display scale possible values: lin, sqrt, cbrt, log, 4thrt, 5thrt

• fscale (str) – set frequency scale possible values: lin, log

• saturation (float) – color saturation multiplier

• win_func (str) – set window function possible values: rect, bartlett, hann, hanning, hamming, blackman, welch, flattop, bharris, bnuttall, bhann, sine, nuttall, lanczos, gauss, tukey, dolph, cauchy, parzen, poisson, bohman, kaiser

• orientation (str) – set orientation possible values: vertical, horizontal

• gain (float) – set scale gain

• legend (bool) – draw legend

• rotation (float) – color rotation

• start (int) – start frequency

• stop (int) – stop frequency

• drange (float) – set dynamic range in dBFS

• limit (float) – set upper limit in dBFS

• opacity (float) – set opacity strength

zprp_ffmpeg.generated_filters.showvolume(graph: Stream, rate: str | None = None, b: int | None = None, w: int | None = None, h: int | None = None, f: float | None = None, c: str | None = None, t: bool | None = None, v: bool | None = None, dm: float | None = None, dmc: str | None = None, o: str | None = None, s: int | None = None, p: float | None = None, m: str | None = None, ds: str | None = None)

Convert input audio volume to video output.

Parameters:

• rate (str) – set video rate

• b (int) – set border width

• w (int) – set channel width

• h (int) – set channel height

• f (float) – set fade

• c (str) – set volume color expression

• t (bool) – display channel names

• v (bool) – display volume value

• dm (float) – duration for max value display

• dmc (str) – set color of the max value line

• o (str) – set orientation possible values: h, v

• s (int) – set step size

• p (float) – set background opacity

• m (str) – set mode possible values: p, r

• ds (str) – set display scale possible values: lin, log

zprp_ffmpeg.generated_filters.showwaves(graph: Stream, size: int | None = None, mode: str | None = None, n: int | None = None, rate: str | None = None, split_channels: bool | None = None, colors: str | None = None, scale: str | None = None, draw: str | None = None)

Convert input audio to a video output.

Parameters:

• size (int) – set video size

• mode (str) – select display mode possible values: point, line, p2p, cline

• n (int) – set how many samples to show in the same point

• rate (str) – set video rate

• split_channels (bool) – draw channels separately

• colors (str) – set channels colors

• scale (str) – set amplitude scale possible values: lin, log, sqrt, cbrt

• draw (str) – set draw mode possible values: scale, full

zprp_ffmpeg.generated_filters.showwavespic(graph: Stream, size: int | None = None, split_channels: bool | None = None, colors: str | None = None, scale: str | None = None, draw: str | None = None, filter: str | None = None)

Convert input audio to a video output single picture.

Parameters:

• size (int) – set video size

• split_channels (bool) – draw channels separately

• colors (str) – set channels colors

• scale (str) – set amplitude scale possible values: lin, log, sqrt, cbrt

• draw (str) – set draw mode possible values: scale, full

• filter (str) – set filter mode possible values: average, peak

zprp_ffmpeg.generated_filters.shuffleframes(graph: Stream, mapping: str | None = None)

Shuffle video frames.

Parameters:

mapping (str) – set destination indexes of input frames

zprp_ffmpeg.generated_filters.shufflepixels(graph: Stream, direction: str | None = None, mode: str | None = None, width: int | None = None, height: int | None = None, seed: int | None = None)

Shuffle video pixels.

Parameters:

• direction (str) – set shuffle direction possible values: forward, inverse

• mode (str) – set shuffle mode possible values: horizontal, vertical, block

• width (int) – set block width

• height (int) – set block height

• seed (int) – set random seed

zprp_ffmpeg.generated_filters.shuffleplanes(graph: Stream, map0: int | None = None, map1: int | None = None, map2: int | None = None, map3: int | None = None)

Shuffle video planes.

Parameters:

• map0 (int) – Index of the input plane to be used as the first output plane

• map1 (int) – Index of the input plane to be used as the second output plane

• map2 (int) – Index of the input plane to be used as the third output plane

• map3 (int) – Index of the input plane to be used as the fourth output plane

zprp_ffmpeg.generated_filters.sidechaincompress(graph: Stream)

Sidechain compressor.

zprp_ffmpeg.generated_filters.sidechaingate(graph: Stream)

Audio sidechain gate.

zprp_ffmpeg.generated_filters.sidedata(graph: Stream, mode: str | None = None, type: str | None = None)

Manipulate video frame side data.

Parameters:

• mode (str) – set a mode of operation possible values: select, delete

• type (str) – set side data type possible values: PANSCAN, A53_CC, STEREO3D, MATRIXENCODING, DOWNMIX_INFO, REPLAYGAIN, DISPLAYMATRIX, AFD, MOTION_VECTORS, SKIP_SAMPLES, AUDIO_SERVICE_TYPE, MASTERING_DISPLAY_METADATA, GOP_TIMECODE, SPHERICAL, CONTENT_LIGHT_LEVEL, ICC_PROFILE, S12M_TIMECOD, DYNAMIC_HDR_PLUS, REGIONS_OF_INTEREST, VIDEO_ENC_PARAMS, SEI_UNREGISTERED, FILM_GRAIN_PARAMS, DETECTION_BOUNDING_BOXES, DETECTION_BBOXES, DOVI_RPU_BUFFER, DOVI_METADATA, DYNAMIC_HDR_VIVID, AMBIENT_VIEWING_ENVIRONMENT, VIDEO_HINT

zprp_ffmpeg.generated_filters.sierpinski(graph: Stream, size: int | None = None, rate: str | None = None, seed: int | None = None, jump: int | None = None, type: str | None = None)

Render a Sierpinski fractal.

Parameters:

• size (int) – set frame size

• rate (str) – set frame rate

• seed (int) – set the seed

• jump (int) – set the jump

• type (str) – set fractal type possible values: carpet, triangle

zprp_ffmpeg.generated_filters.signalstats(graph: Stream, stat: str | None = None, out: str | None = None, c: str | None = None)

Generate statistics from video analysis.

Parameters:

• stat (str) – set statistics filters possible values: tout, vrep, brng

• out (str) – set video filter possible values: tout, vrep, brng

• c (str) – set highlight color

zprp_ffmpeg.generated_filters.signature(graph: Stream, detectmode: str | None = None, nb_inputs: int | None = None, filename: str | None = None, format: str | None = None, th_d: int | None = None, th_dc: int | None = None, th_xh: int | None = None, th_di: int | None = None, th_it: float | None = None)

Calculate the MPEG-7 video signature

Parameters:

• detectmode (str) – set the detectmode possible values: off, full, fast

• nb_inputs (int) – number of inputs

• filename (str) – filename for output files

• format (str) – set output format possible values: binary, xml

• th_d (int) – threshold to detect one word as similar

• th_dc (int) – threshold to detect all words as similar

• th_xh (int) – threshold to detect frames as similar

• th_di (int) – minimum length of matching sequence in frames

• th_it (float) – threshold for relation of good to all frames

zprp_ffmpeg.generated_filters.silencedetect(graph: Stream, n: float | None = None, d: int | None = None, mono: bool | None = None)

Detect silence.

Parameters:

• n (float) – set noise tolerance

• d (int) – set minimum duration in seconds

• mono (bool) – check each channel separately

zprp_ffmpeg.generated_filters.silenceremove(graph: Stream, start_periods: int | None = None, start_duration: int | None = None, start_threshold: float | None = None, start_silence: int | None = None, start_mode: str | None = None, stop_periods: int | None = None, stop_duration: int | None = None, stop_threshold: float | None = None, stop_silence: int | None = None, stop_mode: int | None = None, detection: str | None = None, window: int | None = None, timestamp: str | None = None)

Remove silence.

Parameters:

• start_periods (int) – set periods of silence parts to skip from start

• start_duration (int) – set start duration of non-silence part

• start_threshold (float) – set threshold for start silence detection

• start_silence (int) – set start duration of silence part to keep

• start_mode (str) – set which channel will trigger trimming from start possible values: any, all

• stop_periods (int) – set periods of silence parts to skip from end

• stop_duration (int) – set stop duration of silence part

• stop_threshold (float) – set threshold for stop silence detection

• stop_silence (int) – set stop duration of silence part to keep

• stop_mode (int) – set which channel will trigger trimming from end

• detection (str) – set how silence is detected possible values: avg, rms, peak, median, ptp, dev

• window (int) – set duration of window for silence detection

• timestamp (str) – set how every output frame timestamp is processed possible values: write, copy

zprp_ffmpeg.generated_filters.sinc(graph: Stream, sample_rate: int | None = None, nb_samples: int | None = None, hp: float | None = None, lp: float | None = None, phase: float | None = None, beta: float | None = None, att: float | None = None, round: bool | None = None, hptaps: int | None = None, lptaps: int | None = None)

Generate a sinc kaiser-windowed low-pass, high-pass, band-pass, or band-reject FIR coefficients.

Parameters:

• sample_rate (int) – set sample rate

• nb_samples (int) – set the number of samples per requested frame

• hp (float) – set high-pass filter frequency

• lp (float) – set low-pass filter frequency

• phase (float) – set filter phase response

• beta (float) – set kaiser window beta

• att (float) – set stop-band attenuation

• round (bool) – enable rounding

• hptaps (int) – set number of taps for high-pass filter

• lptaps (int) – set number of taps for low-pass filter

zprp_ffmpeg.generated_filters.sine(graph: Stream, frequency: float | None = None, beep_factor: float | None = None, sample_rate: int | None = None, duration: int | None = None, samples_per_frame: str | None = None)

Generate sine wave audio signal.

Parameters:

• frequency (float) – set the sine frequency

• beep_factor (float) – set the beep frequency factor

• sample_rate (int) – set the sample rate

• duration (int) – set the audio duration

• samples_per_frame (str) – set the number of samples per frame

zprp_ffmpeg.generated_filters.siti(graph: Stream, print_summary: bool | None = None)

Calculate spatial information (SI) and temporal information (TI).

Parameters:

print_summary (bool) – Print summary showing average values

zprp_ffmpeg.generated_filters.smartblur(graph: Stream, luma_radius: float | None = None, lr: float | None = None, luma_strength: float | None = None, ls: float | None = None, luma_threshold: int | None = None, lt: int | None = None, chroma_radius: float | None = None, cr: float | None = None, chroma_strength: float | None = None, cs: float | None = None, chroma_threshold: int | None = None, ct: int | None = None)

Blur the input video without impacting the outlines.

Parameters:

• luma_radius (float) – set luma radius

• lr (float) – set luma radius

• luma_strength (float) – set luma strength

• ls (float) – set luma strength

• luma_threshold (int) – set luma threshold

• lt (int) – set luma threshold

• chroma_radius (float) – set chroma radius

• cr (float) – set chroma radius

• chroma_strength (float) – set chroma strength

• cs (float) – set chroma strength

• chroma_threshold (int) – set chroma threshold

• ct (int) – set chroma threshold

zprp_ffmpeg.generated_filters.smptebars(graph: Stream)

Generate SMPTE color bars.

zprp_ffmpeg.generated_filters.smptehdbars(graph: Stream)

Generate SMPTE HD color bars.

zprp_ffmpeg.generated_filters.sobel(graph: Stream)

Apply sobel operator.

zprp_ffmpeg.generated_filters.spectrumsynth(graph: Stream, sample_rate: int | None = None, channels: int | None = None, scale: str | None = None, slide: str | None = None, win_func: str | None = None, overlap: float | None = None, orientation: str | None = None)

Convert input spectrum videos to audio output.

Parameters:

• sample_rate (int) – set sample rate

• channels (int) – set channels

• scale (str) – set input amplitude scale possible values: lin, log

• slide (str) – set input sliding mode possible values: replace, scroll, fullframe, rscroll

• win_func (str) – set window function possible values: rect, bartlett, hann, hanning, hamming, blackman, welch, flattop, bharris, bnuttall, bhann, sine, nuttall, lanczos, gauss, tukey, dolph, cauchy, parzen, poisson, bohman, kaiser

• overlap (float) – set window overlap

• orientation (str) – set orientation possible values: vertical, horizontal

zprp_ffmpeg.generated_filters.speechnorm(graph: Stream, peak: float | None = None, expansion: float | None = None, compression: float | None = None, threshold: float | None = None, _raise: float | None = None, fall: float | None = None, channels: str | None = None, invert: bool | None = None, link: bool | None = None, rms: float | None = None)

Speech Normalizer.

Parameters:

• peak (float) – set the peak value

• expansion (float) – set the max expansion factor

• compression (float) – set the max compression factor

• threshold (float) – set the threshold value

• raise (float) – set the expansion raising amount

• fall (float) – set the compression raising amount

• channels (str) – set channels to filter

• invert (bool) – set inverted filtering

• link (bool) – set linked channels filtering

• rms (float) – set the RMS value

zprp_ffmpeg.generated_filters.spp(graph: Stream, quality: int | None = None, qp: int | None = None, mode: str | None = None, use_bframe_qp: bool | None = None)

Apply a simple post processing filter.

Parameters:

• quality (int) – set quality

• qp (int) – force a constant quantizer parameter

• mode (str) – set thresholding mode possible values: hard, soft

• use_bframe_qp (bool) – use B-frames’ QP

zprp_ffmpeg.generated_filters.sr(graph: Stream, dnn_backend: int | None = None, scale_factor: int | None = None, model: str | None = None, input: str | None = None, output: str | None = None)

Apply DNN-based image super resolution to the input.

Parameters:

• dnn_backend (int) – DNN backend used for model execution

• scale_factor (int) – scale factor for SRCNN model

• model (str) – path to model file specifying network architecture and its parameters

• input (str) – input name of the model

• output (str) – output name of the model

zprp_ffmpeg.generated_filters.ssim(graph: Stream, stats_file: str | None = None)

Calculate the SSIM between two video streams.

Parameters:

stats_file (str) – Set file where to store per-frame difference information

zprp_ffmpeg.generated_filters.ssim360(graph: Stream, stats_file: str | None = None, compute_chroma: int | None = None, frame_skip_ratio: int | None = None, ref_projection: str | None = None, main_projection: int | None = None, ref_stereo: str | None = None, main_stereo: int | None = None, ref_pad: float | None = None, main_pad: float | None = None, use_tape: int | None = None, heatmap_str: str | None = None, default_heatmap_width: int | None = None, default_heatmap_height: int | None = None)

Calculate the SSIM between two 360 video streams.

Parameters:

• stats_file (str) – Set file where to store per-frame difference information

• compute_chroma (int) – Specifies if non-luma channels must be computed

• frame_skip_ratio (int) – Specifies the number of frames to be skipped from evaluation, for every evaluated frame

• ref_projection (str) – projection of the reference video possible values: e, equirect, c3x2, c2x3, barrel, barrelsplit

• main_projection (int) – projection of the main video

• ref_stereo (str) – stereo format of the reference video possible values: mono, tb, lr

• main_stereo (int) – stereo format of main video

• ref_pad (float) – Expansion (padding) coefficient for each cube face of the reference video

• main_pad (float) – Expansion (padding) coeffiecient for each cube face of the main video

• use_tape (int) – Specifies if the tape based SSIM 360 algorithm must be used independent of the input video types

• heatmap_str (str) – Heatmap data for view-based evaluation. For heatmap file format, please refer to EntSphericalVideoHeatmapData.

• default_heatmap_width (int) – Default heatmap dimension. Will be used when dimension is not specified in heatmap data.

• default_heatmap_height (int) – Default heatmap dimension. Will be used when dimension is not specified in heatmap data.

zprp_ffmpeg.generated_filters.stereo3d(graph: Stream, _in: str | None = None, out: str | None = None)

Convert video stereoscopic 3D view.

Parameters:

• in (str) – set input format possible values: ab2l, tb2l, ab2r, tb2r, abl, tbl, abr, tbr, al, ar, sbs2l, sbs2r, sbsl, sbsr, irl, irr, icl, icr

• out (str) – set output format possible values: ab2l, tb2l, ab2r, tb2r, abl, tbl, abr, tbr, agmc, agmd, agmg, agmh, al, ar, arbg, arcc, arcd, arcg, arch, argg, aybc, aybd, aybg, aybh, irl, irr, ml, mr, sbs2l, sbs2r, sbsl, sbsr, chl, chr, icl, icr, hdmi

zprp_ffmpeg.generated_filters.stereotools(graph: Stream, level_in: float | None = None, level_out: float | None = None, balance_in: float | None = None, balance_out: float | None = None, softclip: bool | None = None, mutel: bool | None = None, muter: bool | None = None, phasel: bool | None = None, phaser: bool | None = None, mode: str | None = None, slev: float | None = None, sbal: float | None = None, mlev: float | None = None, mpan: float | None = None, base: float | None = None, delay: float | None = None, sclevel: float | None = None, phase: float | None = None, bmode_in: str | None = None, bmode_out: int | None = None)

Apply various stereo tools.

Parameters:

• level_in (float) – set level in

• level_out (float) – set level out

• balance_in (float) – set balance in

• balance_out (float) – set balance out

• softclip (bool) – enable softclip

• mutel (bool) – mute L

• muter (bool) – mute R

• phasel (bool) – phase L

• phaser (bool) – phase R

• mode (str) – set stereo mode possible values: lr>lr, lr>ms, ms>lr, lr>ll, lr>rr, lr>l+r, lr>rl, ms>ll, ms>rr, ms>rl, lr>l-r

• slev (float) – set side level

• sbal (float) – set side balance

• mlev (float) – set middle level

• mpan (float) – set middle pan

• base (float) – set stereo base

• delay (float) – set delay

• sclevel (float) – set S/C level

• phase (float) – set stereo phase

• bmode_in (str) – set balance in mode possible values: balance, amplitude, power

• bmode_out (int) – set balance out mode

zprp_ffmpeg.generated_filters.stereowiden(graph: Stream, delay: float | None = None, feedback: float | None = None, crossfeed: float | None = None, drymix: float | None = None)

Apply stereo widening effect.

Parameters:

• delay (float) – set delay time

• feedback (float) – set feedback gain

• crossfeed (float) – set cross feed

• drymix (float) – set dry-mix

zprp_ffmpeg.generated_filters.super2xsai(graph: Stream)

Scale the input by 2x using the Super2xSaI pixel art algorithm.

zprp_ffmpeg.generated_filters.superequalizer(graph: Stream, _1b: float | None = None, _2b: float | None = None, _3b: float | None = None, _4b: float | None = None, _5b: float | None = None, _6b: float | None = None, _7b: float | None = None, _8b: float | None = None, _9b: float | None = None, _10b: float | None = None, _11b: float | None = None, _12b: float | None = None, _13b: float | None = None, _14b: float | None = None, _15b: float | None = None, _16b: float | None = None, _17b: float | None = None, _18b: float | None = None)

Apply 18 band equalization filter.

Parameters:

• 1b (float) – set 65Hz band gain

• 2b (float) – set 92Hz band gain

• 3b (float) – set 131Hz band gain

• 4b (float) – set 185Hz band gain

• 5b (float) – set 262Hz band gain

• 6b (float) – set 370Hz band gain

• 7b (float) – set 523Hz band gain

• 8b (float) – set 740Hz band gain

• 9b (float) – set 1047Hz band gain

• 10b (float) – set 1480Hz band gain

• 11b (float) – set 2093Hz band gain

• 12b (float) – set 2960Hz band gain

• 13b (float) – set 4186Hz band gain

• 14b (float) – set 5920Hz band gain

• 15b (float) – set 8372Hz band gain

• 16b (float) – set 11840Hz band gain

• 17b (float) – set 16744Hz band gain

• 18b (float) – set 20000Hz band gain

zprp_ffmpeg.generated_filters.surround(graph: Stream, chl_out: str | None = None, chl_in: str | None = None, level_in: float | None = None, level_out: float | None = None, lfe: bool | None = None, lfe_low: int | None = None, lfe_high: int | None = None, lfe_mode: str | None = None, smooth: float | None = None, angle: float | None = None, focus: float | None = None, fc_in: float | None = None, fc_out: float | None = None, fl_in: float | None = None, fl_out: float | None = None, fr_in: float | None = None, fr_out: float | None = None, sl_in: float | None = None, sl_out: float | None = None, sr_in: float | None = None, sr_out: float | None = None, bl_in: float | None = None, bl_out: float | None = None, br_in: float | None = None, br_out: float | None = None, bc_in: float | None = None, bc_out: float | None = None, lfe_in: float | None = None, lfe_out: float | None = None, allx: float | None = None, ally: float | None = None, fcx: float | None = None, flx: float | None = None, frx: float | None = None, blx: float | None = None, brx: float | None = None, slx: float | None = None, srx: float | None = None, bcx: float | None = None, fcy: float | None = None, fly: float | None = None, fry: float | None = None, bly: float | None = None, bry: float | None = None, sly: float | None = None, sry: float | None = None, bcy: float | None = None, win_size: int | None = None, win_func: str | None = None, overlap: float | None = None)

Apply audio surround upmix filter.

Parameters:

• chl_out (str) – set output channel layout

• chl_in (str) – set input channel layout

• level_in (float) – set input level

• level_out (float) – set output level

• lfe (bool) – output LFE

• lfe_low (int) – LFE low cut off

• lfe_high (int) – LFE high cut off

• lfe_mode (str) – set LFE channel mode possible values: add, sub

• smooth (float) – set temporal smoothness strength

• angle (float) – set soundfield transform angle

• focus (float) – set soundfield transform focus

• fc_in (float) – set front center channel input level

• fc_out (float) – set front center channel output level

• fl_in (float) – set front left channel input level

• fl_out (float) – set front left channel output level

• fr_in (float) – set front right channel input level

• fr_out (float) – set front right channel output level

• sl_in (float) – set side left channel input level

• sl_out (float) – set side left channel output level

• sr_in (float) – set side right channel input level

• sr_out (float) – set side right channel output level

• bl_in (float) – set back left channel input level

• bl_out (float) – set back left channel output level

• br_in (float) – set back right channel input level

• br_out (float) – set back right channel output level

• bc_in (float) – set back center channel input level

• bc_out (float) – set back center channel output level

• lfe_in (float) – set lfe channel input level

• lfe_out (float) – set lfe channel output level

• allx (float) – set all channel’s x spread

• ally (float) – set all channel’s y spread

• fcx (float) – set front center channel x spread

• flx (float) – set front left channel x spread

• frx (float) – set front right channel x spread

• blx (float) – set back left channel x spread

• brx (float) – set back right channel x spread

• slx (float) – set side left channel x spread

• srx (float) – set side right channel x spread

• bcx (float) – set back center channel x spread

• fcy (float) – set front center channel y spread

• fly (float) – set front left channel y spread

• fry (float) – set front right channel y spread

• bly (float) – set back left channel y spread

• bry (float) – set back right channel y spread

• sly (float) – set side left channel y spread

• sry (float) – set side right channel y spread

• bcy (float) – set back center channel y spread

• win_size (int) – set window size

• win_func (str) – set window function possible values: rect, bartlett, hann, hanning, hamming, blackman, welch, flattop, bharris, bnuttall, bhann, sine, nuttall, lanczos, gauss, tukey, dolph, cauchy, parzen, poisson, bohman, kaiser

• overlap (float) – set window overlap

zprp_ffmpeg.generated_filters.swaprect(graph: Stream, w: str | None = None, h: str | None = None, x1: str | None = None, y1: str | None = None, x2: str | None = None, y2: str | None = None)

Swap 2 rectangular objects in video.

Parameters:

• w (str) – set rect width

• h (str) – set rect height

• x1 (str) – set 1st rect x top left coordinate

• y1 (str) – set 1st rect y top left coordinate

• x2 (str) – set 2nd rect x top left coordinate

• y2 (str) – set 2nd rect y top left coordinate

zprp_ffmpeg.generated_filters.swapuv(graph: Stream)

Swap U and V components.

zprp_ffmpeg.generated_filters.tblend(graph: Stream)

Blend successive frames.

zprp_ffmpeg.generated_filters.telecine(graph: Stream, first_field: str | None = None, pattern: str | None = None)

Apply a telecine pattern.

Parameters:

• first_field (str) – select first field possible values: top, t, bottom, b

• pattern (str) – pattern that describe for how many fields a frame is to be displayed

zprp_ffmpeg.generated_filters.testsrc(graph: Stream, size: int | None = None, rate: str | None = None, duration: int | None = None, sar: int | None = None, decimals: int | None = None)

Generate test pattern.

Parameters:

• size (int) – set video size

• rate (str) – set video rate

• duration (int) – set video duration

• sar (int) – set video sample aspect ratio

• decimals (int) – set number of decimals to show

zprp_ffmpeg.generated_filters.testsrc2(graph: Stream, size: int | None = None, rate: str | None = None, duration: int | None = None, sar: int | None = None, alpha: int | None = None)

Generate another test pattern.

Parameters:

• size (int) – set video size

• rate (str) – set video rate

• duration (int) – set video duration

• sar (int) – set video sample aspect ratio

• alpha (int) – set global alpha (opacity)

zprp_ffmpeg.generated_filters.thistogram(graph: Stream, width: int | None = None, display_mode: str | None = None, levels_mode: str | None = None, components: int | None = None, bgopacity: float | None = None, envelope: bool | None = None, ecolor: str | None = None, slide: str | None = None)

Compute and draw a temporal histogram.

Parameters:

• width (int) – set width

• display_mode (str) – set display mode possible values: overlay, parade, stack

• levels_mode (str) – set levels mode possible values: linear, logarithmic

• components (int) – set color components to display

• bgopacity (float) – set background opacity

• envelope (bool) – display envelope

• ecolor (str) – set envelope color

• slide (str) – set slide mode possible values: frame, replace, scroll, rscroll, picture

zprp_ffmpeg.generated_filters.threshold(graph: Stream, planes: int | None = None)

Threshold first video stream using other video streams.

Parameters:

planes (int) – set planes to filter

zprp_ffmpeg.generated_filters.thumbnail(graph: Stream, n: int | None = None, log: str | None = None)

Select the most representative frame in a given sequence of consecutive frames.

Parameters:

• n (int) – set the frames batch size

• log (str) – force stats logging level possible values: quiet, info, verbose

zprp_ffmpeg.generated_filters.tile(graph: Stream, layout: int | None = None, nb_frames: int | None = None, margin: int | None = None, padding: int | None = None, color: str | None = None, overlap: int | None = None, init_padding: int | None = None)

Tile several successive frames together.

Parameters:

• layout (int) – set grid size

• nb_frames (int) – set maximum number of frame to render

• margin (int) – set outer border margin in pixels

• padding (int) – set inner border thickness in pixels

• color (str) – set the color of the unused area

• overlap (int) – set how many frames to overlap for each render

• init_padding (int) – set how many frames to initially pad

zprp_ffmpeg.generated_filters.tiltandshift(graph: Stream, tilt: int | None = None, start: str | None = None, end: str | None = None, hold: int | None = None, pad: int | None = None)

Generate a tilt-and-shift’d video.

Parameters:

• tilt (int) – Tilt the video horizontally while shifting

• start (str) – Action at the start of input possible values: none, frame, black

• end (str) – Action at the end of input possible values: none, frame, black

• hold (int) – Number of columns to hold at the start of the video

• pad (int) – Number of columns to pad at the end of the video

zprp_ffmpeg.generated_filters.tiltshelf(graph: Stream)

Apply a tilt shelf filter.

zprp_ffmpeg.generated_filters.tinterlace(graph: Stream, mode: str | None = None, flags: str | None = None)

Perform temporal field interlacing.

Parameters:

• mode (str) – select interlace mode possible values: merge, drop_even, drop_odd, pad, interleave_top, interleave_bottom, interlacex2, mergex2

• flags (str) – set flags possible values: low_pass_filter, vlpf, complex_filter, cvlpf, exact_tb, bypass_il

zprp_ffmpeg.generated_filters.tlut2(graph: Stream, c0: str | None = None, c1: str | None = None, c2: str | None = None, c3: str | None = None)

Compute and apply a lookup table from two successive frames.

Parameters:

• c0 (str) – set component #0 expression

• c1 (str) – set component #1 expression

• c2 (str) – set component #2 expression

• c3 (str) – set component #3 expression

zprp_ffmpeg.generated_filters.tmedian(graph: Stream, radius: int | None = None, planes: int | None = None, percentile: float | None = None)

Pick median pixels from successive frames.

Parameters:

• radius (int) – set median filter radius

• planes (int) – set planes to filter

• percentile (float) – set percentile

zprp_ffmpeg.generated_filters.tmidequalizer(graph: Stream, radius: int | None = None, sigma: float | None = None, planes: int | None = None)

Apply Temporal Midway Equalization.

Parameters:

• radius (int) – set radius

• sigma (float) – set sigma

• planes (int) – set planes

zprp_ffmpeg.generated_filters.tmix(graph: Stream, frames: int | None = None, weights: str | None = None, scale: float | None = None, planes: str | None = None)

Mix successive video frames.

Parameters:

• frames (int) – set number of successive frames to mix

• weights (str) – set weight for each frame

• scale (float) – set scale

• planes (str) – set what planes to filter

zprp_ffmpeg.generated_filters.tonemap(graph: Stream, tonemap: str | None = None, param: float | None = None, desat: float | None = None, peak: float | None = None)

Conversion to/from different dynamic ranges.

Parameters:

• tonemap (str) – tonemap algorithm selection possible values: none, linear, gamma, clip, reinhard, hable, mobius

• param (float) – tonemap parameter

• desat (float) – desaturation strength

• peak (float) – signal peak override

zprp_ffmpeg.generated_filters.tonemap_opencl(graph: Stream, tonemap: str | None = None, transfer: str | None = None, matrix: str | None = None, primaries: str | None = None, range: str | None = None, format: str | None = None, peak: float | None = None, param: float | None = None, desat: float | None = None, threshold: float | None = None)

Perform HDR to SDR conversion with tonemapping.

Parameters:

• tonemap (str) – tonemap algorithm selection possible values: none, linear, gamma, clip, reinhard, hable, mobius

• transfer (str) – set transfer characteristic possible values: bt709, bt2020

• matrix (str) – set colorspace matrix possible values: bt709, bt2020

• primaries (str) – set color primaries possible values: bt709, bt2020

• range (str) – set color range possible values: tv, pc, limited, full

• format (str) – output pixel format

• peak (float) – signal peak override

• param (float) – tonemap parameter

• desat (float) – desaturation parameter

• threshold (float) – scene detection threshold

zprp_ffmpeg.generated_filters.tpad(graph: Stream, start: int | None = None, stop: int | None = None, start_mode: str | None = None, stop_mode: int | None = None, start_duration: int | None = None, stop_duration: int | None = None, color: str | None = None)

Temporarily pad video frames.

Parameters:

• start (int) – set the number of frames to delay input

• stop (int) – set the number of frames to add after input finished

• start_mode (str) – set the mode of added frames to start possible values: add, clone

• stop_mode (int) – set the mode of added frames to end

• start_duration (int) – set the duration to delay input

• stop_duration (int) – set the duration to pad input

• color (str) – set the color of the added frames

zprp_ffmpeg.generated_filters.transpose(graph: Stream, dir: str | None = None, passthrough: str | None = None)

Transpose input video.

Parameters:

• dir (str) – set transpose direction possible values: cclock_flip, clock, cclock, clock_flip

• passthrough (str) – do not apply transposition if the input matches the specified geometry possible values: none, portrait, landscape

zprp_ffmpeg.generated_filters.transpose_opencl(graph: Stream, dir: str | None = None, passthrough: str | None = None)

Transpose input video

Parameters:

• dir (str) – set transpose direction possible values: cclock_flip, clock, cclock, clock_flip

• passthrough (str) – do not apply transposition if the input matches the specified geometry possible values: none, portrait, landscape

zprp_ffmpeg.generated_filters.transpose_vaapi(graph: Stream, dir: str | None = None, passthrough: str | None = None)

VAAPI VPP for transpose

Parameters:

• dir (str) – set transpose direction possible values: cclock_flip, clock, cclock, clock_flip, reversal, hflip, vflip

• passthrough (str) – do not apply transposition if the input matches the specified geometry possible values: none, portrait, landscape

zprp_ffmpeg.generated_filters.transpose_vulkan(graph: Stream, dir: str | None = None, passthrough: str | None = None)

Transpose Vulkan Filter

Parameters:

• dir (str) – set transpose direction possible values: cclock_flip, clock, cclock, clock_flip

• passthrough (str) – do not apply transposition if the input matches the specified geometry possible values: none, portrait, landscape

zprp_ffmpeg.generated_filters.treble(graph: Stream)

Boost or cut upper frequencies.

zprp_ffmpeg.generated_filters.tremolo(graph: Stream, f: float | None = None, d: float | None = None)

Apply tremolo effect.

Parameters:

• f (float) – set frequency in hertz

• d (float) – set depth as percentage

zprp_ffmpeg.generated_filters.trim(graph: Stream, start: int | None = None, end: int | None = None, start_pts: int | None = None, end_pts: int | None = None, duration: int | None = None, start_frame: int | None = None, end_frame: int | None = None)

Pick one continuous section from the input, drop the rest.

Parameters:

• start (int) – Timestamp of the first frame that should be passed

• end (int) – Timestamp of the first frame that should be dropped again

• start_pts (int) – Timestamp of the first frame that should be passed

• end_pts (int) – Timestamp of the first frame that should be dropped again

• duration (int) – Maximum duration of the output

• start_frame (int) – Number of the first frame that should be passed to the output

• end_frame (int) – Number of the first frame that should be dropped again

zprp_ffmpeg.generated_filters.unpremultiply(graph: Stream)

UnPreMultiply first stream with first plane of second stream.

zprp_ffmpeg.generated_filters.unsharp(graph: Stream, luma_msize_x: int | None = None, luma_msize_y: int | None = None, luma_amount: float | None = None, chroma_msize_x: int | None = None, chroma_msize_y: int | None = None, chroma_amount: float | None = None, alpha_msize_x: int | None = None, alpha_msize_y: int | None = None, alpha_amount: float | None = None)

Sharpen or blur the input video.

Parameters:

• luma_msize_x (int) – set luma matrix horizontal size

• luma_msize_y (int) – set luma matrix vertical size

• luma_amount (float) – set luma effect strength

• chroma_msize_x (int) – set chroma matrix horizontal size

• chroma_msize_y (int) – set chroma matrix vertical size

• chroma_amount (float) – set chroma effect strength

• alpha_msize_x (int) – set alpha matrix horizontal size

• alpha_msize_y (int) – set alpha matrix vertical size

• alpha_amount (float) – set alpha effect strength

zprp_ffmpeg.generated_filters.unsharp_opencl(graph: Stream, luma_msize_x: float | None = None, luma_msize_y: float | None = None, luma_amount: float | None = None, chroma_msize_x: float | None = None, chroma_msize_y: float | None = None, chroma_amount: float | None = None)

Apply unsharp mask to input video

Parameters:

• luma_msize_x (float) – Set luma mask horizontal diameter (pixels)

• luma_msize_y (float) – Set luma mask vertical diameter (pixels)

• luma_amount (float) – Set luma amount (multiplier)

• chroma_msize_x (float) – Set chroma mask horizontal diameter (pixels after subsampling)

• chroma_msize_y (float) – Set chroma mask vertical diameter (pixels after subsampling)

• chroma_amount (float) – Set chroma amount (multiplier)

zprp_ffmpeg.generated_filters.untile(graph: Stream, layout: int | None = None)

Untile a frame into a sequence of frames.

Parameters:

layout (int) – set grid size

zprp_ffmpeg.generated_filters.uspp(graph: Stream, quality: int | None = None, qp: int | None = None, use_bframe_qp: bool | None = None, codec: str | None = None)

Apply Ultra Simple / Slow Post-processing filter.

Parameters:

• quality (int) – set quality

• qp (int) – force a constant quantizer parameter

• use_bframe_qp (bool) – use B-frames’ QP

• codec (str) – Codec name

zprp_ffmpeg.generated_filters.v360(graph: Stream, input: str | None = None, output: str | None = None, interp: str | None = None, w: int | None = None, h: int | None = None, in_stereo: str | None = None, out_stereo: str | None = None, in_forder: str | None = None, out_forder: str | None = None, in_frot: str | None = None, out_frot: str | None = None, in_pad: float | None = None, out_pad: float | None = None, fin_pad: int | None = None, fout_pad: int | None = None, yaw: float | None = None, pitch: float | None = None, roll: float | None = None, rorder: str | None = None, h_fov: float | None = None, v_fov: float | None = None, d_fov: float | None = None, h_flip: bool | None = None, v_flip: bool | None = None, d_flip: bool | None = None, ih_flip: bool | None = None, iv_flip: bool | None = None, in_trans: bool | None = None, out_trans: bool | None = None, ih_fov: float | None = None, iv_fov: float | None = None, id_fov: float | None = None, h_offset: float | None = None, v_offset: float | None = None, alpha_mask: bool | None = None, reset_rot: bool | None = None)

Convert 360 projection of video.

Parameters:

• input (str) – set input projection possible values: e, equirect, c3x2, c6x1, eac, dfisheye, flat, rectilinear, gnomonic, barrel, fb, c1x6, sg, mercator, ball, hammer, sinusoidal, fisheye, pannini, cylindrical, tetrahedron, barrelsplit, tsp, hequirect, he, equisolid, og, octahedron, cylindricalea

• output (str) – set output projection possible values: e, equirect, c3x2, c6x1, eac, dfisheye, flat, rectilinear, gnomonic, barrel, fb, c1x6, sg, mercator, ball, hammer, sinusoidal, fisheye, pannini, cylindrical, perspective, tetrahedron, barrelsplit, tsp, hequirect, he, equisolid, og, octahedron, cylindricalea

• interp (str) – set interpolation method possible values: near, nearest, line, linear, lagrange9, cube, cubic, lanc, lanczos, sp16, spline16, gauss, gaussian, mitchell

• w (int) – output width

• h (int) – output height

• in_stereo (str) – input stereo format possible values: 2d, sbs, tb

• out_stereo (str) – output stereo format possible values: 2d, sbs, tb

• in_forder (str) – input cubemap face order

• out_forder (str) – output cubemap face order

• in_frot (str) – input cubemap face rotation

• out_frot (str) – output cubemap face rotation

• in_pad (float) – percent input cubemap pads

• out_pad (float) – percent output cubemap pads

• fin_pad (int) – fixed input cubemap pads

• fout_pad (int) – fixed output cubemap pads

• yaw (float) – yaw rotation

• pitch (float) – pitch rotation

• roll (float) – roll rotation

• rorder (str) – rotation order

• h_fov (float) – output horizontal field of view

• v_fov (float) – output vertical field of view

• d_fov (float) – output diagonal field of view

• h_flip (bool) – flip out video horizontally

• v_flip (bool) – flip out video vertically

• d_flip (bool) – flip out video indepth

• ih_flip (bool) – flip in video horizontally

• iv_flip (bool) – flip in video vertically

• in_trans (bool) – transpose video input

• out_trans (bool) – transpose video output

• ih_fov (float) – input horizontal field of view

• iv_fov (float) – input vertical field of view

• id_fov (float) – input diagonal field of view

• h_offset (float) – output horizontal off-axis offset

• v_offset (float) – output vertical off-axis offset

• alpha_mask (bool) – build mask in alpha plane

• reset_rot (bool) – reset rotation

zprp_ffmpeg.generated_filters.vaguedenoiser(graph: Stream, threshold: float | None = None, method: str | None = None, nsteps: int | None = None, percent: float | None = None, planes: int | None = None, type: str | None = None)

Apply a Wavelet based Denoiser.

Parameters:

• threshold (float) – set filtering strength

• method (str) – set filtering method possible values: hard, soft, garrote

• nsteps (int) – set number of steps

• percent (float) – set percent of full denoising

• planes (int) – set planes to filter

• type (str) – set threshold type possible values: universal, bayes

zprp_ffmpeg.generated_filters.varblur(graph: Stream, min_r: int | None = None, max_r: int | None = None, planes: int | None = None)

Apply Variable Blur filter.

Parameters:

• min_r (int) – set min blur radius

• max_r (int) – set max blur radius

• planes (int) – set planes to filter

zprp_ffmpeg.generated_filters.vectorscope(graph: Stream, mode: str | None = None, x: int | None = None, y: int | None = None, intensity: float | None = None, envelope: str | None = None, graticule: str | None = None, opacity: float | None = None, flags: str | None = None, bgopacity: float | None = None, lthreshold: float | None = None, hthreshold: float | None = None, colorspace: str | None = None, tint0: float | None = None, t0: float | None = None, tint1: float | None = None, t1: float | None = None)

Video vectorscope.

Parameters:

• mode (str) – set vectorscope mode possible values: gray, tint, color, color2, color3, color4, color5

• x (int) – set color component on X axis

• y (int) – set color component on Y axis

• intensity (float) – set intensity

• envelope (str) – set envelope possible values: none, instant, peak, peak+instant

• graticule (str) – set graticule possible values: none, green, color, invert

• opacity (float) – set graticule opacity

• flags (str) – set graticule flags possible values: white, black, name

• bgopacity (float) – set background opacity

• lthreshold (float) – set low threshold

• hthreshold (float) – set high threshold

• colorspace (str) – set colorspace possible values: auto, 601, 709

• tint0 (float) – set 1st tint

• t0 (float) – set 1st tint

• tint1 (float) – set 2nd tint

• t1 (float) – set 2nd tint

zprp_ffmpeg.generated_filters.vflip(graph: Stream)

Flip the input video vertically.

zprp_ffmpeg.generated_filters.vflip_vulkan(graph: Stream)

Vertically flip the input video in Vulkan

zprp_ffmpeg.generated_filters.vfrdet(graph: Stream)

Variable frame rate detect filter.

zprp_ffmpeg.generated_filters.vibrance(graph: Stream, intensity: float | None = None, rbal: float | None = None, gbal: float | None = None, bbal: float | None = None, rlum: float | None = None, glum: float | None = None, blum: float | None = None, alternate: bool | None = None)

Boost or alter saturation.

Parameters:

• intensity (float) – set the intensity value

• rbal (float) – set the red balance value

• gbal (float) – set the green balance value

• bbal (float) – set the blue balance value

• rlum (float) – set the red luma coefficient

• glum (float) – set the green luma coefficient

• blum (float) – set the blue luma coefficient

• alternate (bool) – use alternate colors

zprp_ffmpeg.generated_filters.vibrato(graph: Stream, f: float | None = None, d: float | None = None)

Apply vibrato effect.

Parameters:

• f (float) – set frequency in hertz

• d (float) – set depth as percentage

zprp_ffmpeg.generated_filters.vif(graph: Stream)

Calculate the VIF between two video streams.

zprp_ffmpeg.generated_filters.vignette(graph: Stream, angle: str | None = None, x0: str | None = None, y0: str | None = None, mode: str | None = None, eval: str | None = None, dither: bool | None = None, aspect: int | None = None)

Make or reverse a vignette effect.

Parameters:

• angle (str) – set lens angle

• x0 (str) – set circle center position on x-axis

• y0 (str) – set circle center position on y-axis

• mode (str) – set forward/backward mode possible values: forward, backward

• eval (str) – specify when to evaluate expressions possible values: init, frame

• dither (bool) – set dithering

• aspect (int) – set aspect ratio

zprp_ffmpeg.generated_filters.virtualbass(graph: Stream, cutoff: float | None = None, strength: float | None = None)

Audio Virtual Bass.

Parameters:

• cutoff (float) – set virtual bass cutoff

• strength (float) – set virtual bass strength

zprp_ffmpeg.generated_filters.vmafmotion(graph: Stream, stats_file: str | None = None)

Calculate the VMAF Motion score.

Parameters:

stats_file (str) – Set file where to store per-frame difference information

zprp_ffmpeg.generated_filters.volume(graph: Stream, volume: str | None = None, precision: str | None = None, eval: str | None = None, replaygain: str | None = None, replaygain_preamp: float | None = None, replaygain_noclip: bool | None = None)

Change input volume.

Parameters:

• volume (str) – set volume adjustment expression

• precision (str) – select mathematical precision possible values: fixed, float, double

• eval (str) – specify when to evaluate expressions possible values: once, frame

• replaygain (str) – Apply replaygain side data when present possible values: drop, ignore, track, album

• replaygain_preamp (float) – Apply replaygain pre-amplification

• replaygain_noclip (bool) – Apply replaygain clipping prevention

zprp_ffmpeg.generated_filters.volumedetect(graph: Stream)

Detect audio volume.

zprp_ffmpeg.generated_filters.vstack(graph: Stream)

Stack video inputs vertically.

zprp_ffmpeg.generated_filters.w3fdif(graph: Stream, filter: str | None = None, mode: str | None = None, parity: str | None = None, deint: str | None = None)

Apply Martin Weston three field deinterlace.

Parameters:

• filter (str) – specify the filter possible values: simple, complex

• mode (str) – specify the interlacing mode possible values: frame, field

• parity (str) – specify the assumed picture field parity possible values: tff, bff, auto

• deint (str) – specify which frames to deinterlace possible values: all, interlaced

zprp_ffmpeg.generated_filters.waveform(graph: Stream, mode: str | None = None, intensity: float | None = None, mirror: bool | None = None, display: str | None = None, components: int | None = None, envelope: str | None = None, filter: str | None = None, graticule: str | None = None, opacity: float | None = None, flags: str | None = None, scale: str | None = None, bgopacity: float | None = None, tint0: float | None = None, t0: float | None = None, tint1: float | None = None, t1: float | None = None, fitmode: str | None = None, input: str | None = None)

Video waveform monitor.

Parameters:

• mode (str) – set mode possible values: row, column

• intensity (float) – set intensity

• mirror (bool) – set mirroring

• display (str) – set display mode possible values: overlay, stack, parade

• components (int) – set components to display

• envelope (str) – set envelope to display possible values: none, instant, peak, peak+instant

• filter (str) – set filter possible values: lowpass, flat, aflat, chroma, color, acolor, xflat, yflat

• graticule (str) – set graticule possible values: none, green, orange, invert

• opacity (float) – set graticule opacity

• flags (str) – set graticule flags possible values: numbers, dots

• scale (str) – set scale possible values: digital, millivolts, ire

• bgopacity (float) – set background opacity

• tint0 (float) – set 1st tint

• t0 (float) – set 1st tint

• tint1 (float) – set 2nd tint

• t1 (float) – set 2nd tint

• fitmode (str) – set fit mode possible values: none, size

• input (str) – set input formats selection possible values: all, first

zprp_ffmpeg.generated_filters.weave(graph: Stream, first_field: str | None = None)

Weave input video fields into frames.

Parameters:

first_field (str) – set first field possible values: top, t, bottom, b

zprp_ffmpeg.generated_filters.xbr(graph: Stream, n: int | None = None)

Scale the input using xBR algorithm.

Parameters:

n (int) – set scale factor

zprp_ffmpeg.generated_filters.xcorrelate(graph: Stream, planes: int | None = None, secondary: str | None = None)

Cross-correlate first video stream with second video stream.

Parameters:

• planes (int) – set planes to cross-correlate

• secondary (str) – when to process secondary frame possible values: first, all

zprp_ffmpeg.generated_filters.xfade(graph: Stream, transition: str | None = None, duration: int | None = None, offset: int | None = None, expr: str | None = None)

Cross fade one video with another video.

Parameters:

• transition (str) – set cross fade transition possible values: custom, fade, wipeleft, wiperight, wipeup, wipedown, slideleft, slideright, slideup, slidedown, circlecrop, rectcrop, distance, fadeblack, fadewhite, radial, smoothleft, smoothright, smoothup, smoothdown, circleopen, circleclose, vertopen, vertclose, horzopen, horzclose, dissolve, pixelize, diagtl, diagtr, diagbl, diagbr, hlslice, hrslice, vuslice, vdslice, hblur, fadegrays, wipetl, wipetr, wipebl, wipebr, squeezeh, squeezev, zoomin, fadefast, fadeslow, hlwind, hrwind, vuwind, vdwind, coverleft, coverright, coverup, coverdown, revealleft, revealright, revealup, revealdown

• duration (int) – set cross fade duration

• offset (int) – set cross fade start relative to first input stream

• expr (str) – set expression for custom transition

zprp_ffmpeg.generated_filters.xfade_opencl(graph: Stream, transition: str | None = None, source: str | None = None, kernel: str | None = None, duration: int | None = None, offset: int | None = None)

Cross fade one video with another video.

Parameters:

• transition (str) – set cross fade transition possible values: custom, fade, wipeleft, wiperight, wipeup, wipedown, slideleft, slideright, slideup, slidedown

• source (str) – set OpenCL program source file for custom transition

• kernel (str) – set kernel name in program file for custom transition

• duration (int) – set cross fade duration

• offset (int) – set cross fade start relative to first input stream

zprp_ffmpeg.generated_filters.xfade_vulkan(graph: Stream, transition: str | None = None, duration: int | None = None, offset: int | None = None)

Cross fade one video with another video.

Parameters:

• transition (str) – set cross fade transition possible values: fade, wipeleft, wiperight, wipeup, wipedown, slidedown, slideup, slideleft, slideright, circleopen, circleclose, dissolve, pixelize, wipetl, wipetr, wipebl, wipebr

• duration (int) – set cross fade duration

• offset (int) – set cross fade start relative to first input stream

zprp_ffmpeg.generated_filters.xmedian(graph: Stream, inputs: int | None = None, planes: int | None = None, percentile: float | None = None)

Pick median pixels from several video inputs.

Parameters:

• inputs (int) – set number of inputs

• planes (int) – set planes to filter

• percentile (float) – set percentile

zprp_ffmpeg.generated_filters.xstack(graph: Stream, inputs: int | None = None, layout: str | None = None, grid: int | None = None, shortest: bool | None = None, fill: str | None = None)

Stack video inputs into custom layout.

Parameters:

• inputs (int) – set number of inputs

• layout (str) – set custom layout

• grid (int) – set fixed size grid layout

• shortest (bool) – force termination when the shortest input terminates

• fill (str) – set the color for unused pixels

zprp_ffmpeg.generated_filters.yadif(graph: Stream)

Deinterlace the input image.

zprp_ffmpeg.generated_filters.yaepblur(graph: Stream, radius: int | None = None, planes: int | None = None, sigma: int | None = None)

Yet another edge preserving blur filter.

Parameters:

• radius (int) – set window radius

• planes (int) – set planes to filter

• sigma (int) – set blur strength

zprp_ffmpeg.generated_filters.yuvtestsrc(graph: Stream)

Generate YUV test pattern.

zprp_ffmpeg.generated_filters.zoneplate(graph: Stream, size: int | None = None, rate: str | None = None, duration: int | None = None, sar: int | None = None, precision: int | None = None, xo: int | None = None, yo: int | None = None, to: int | None = None, k0: int | None = None, kx: int | None = None, ky: int | None = None, kt: int | None = None, kxt: int | None = None, kyt: int | None = None, kxy: int | None = None, kx2: int | None = None, ky2: int | None = None, kt2: int | None = None, ku: int | None = None, kv: int | None = None)

Generate zone-plate.

Parameters:

• size (int) – set video size

• rate (str) – set video rate

• duration (int) – set video duration

• sar (int) – set video sample aspect ratio

• precision (int) – set LUT precision

• xo (int) – set X-axis offset

• yo (int) – set Y-axis offset

• to (int) – set T-axis offset

• k0 (int) – set 0-order phase

• kx (int) – set 1-order X-axis phase

• ky (int) – set 1-order Y-axis phase

• kt (int) – set 1-order T-axis phase

• kxt (int) – set X-axis*T-axis product phase

• kyt (int) – set Y-axis*T-axis product phase

• kxy (int) – set X-axis*Y-axis product phase

• kx2 (int) – set 2-order X-axis phase

• ky2 (int) – set 2-order Y-axis phase

• kt2 (int) – set 2-order T-axis phase

• ku (int) – set 0-order U-color phase

• kv (int) – set 0-order V-color phase

zprp_ffmpeg.generated_filters.zoompan(graph: Stream, zoom: str | None = None, x: str | None = None, y: str | None = None, d: str | None = None, s: int | None = None, fps: str | None = None)

Apply Zoom & Pan effect.

Parameters:

• zoom (str) – set the zoom expression

• x (str) – set the x expression

• y (str) – set the y expression

• d (str) – set the duration expression

• s (int) – set the output image size

• fps (str) – set the output framerate

complex_filters

zprp_ffmpeg.filters.concat(graphs: Iterable[Stream], n: int | None = None, v: int | None = None, a: int | None = None) → Stream

Concatenate audio and video streams, joining them together one after the other.

Parameters:

• n (int) – set the number of segments. Default is 2.

• v (int) – set the number of output video streams, that is also the number of video streams in each segment. Default is 1.

• a (int) – set the number of output audio streams, that is also the number of audio streams in each segment. Default is 0.

zprp_ffmpeg.filters.overlay(main: Stream, sub: Stream, x: str | None = None, y: str | None = None, eof_action: str | None = None, eval: str | None = None, shortest: bool | None = None, format: str | None = None, repeatlast: bool | None = None, alpha: str | None = None) → Stream

Overlay a video source on top of the input.

Parameters:

• x (str) – set the x expression

• y (str) – set the y expression

• eof_action (str) – Action to take when encountering EOF from secondary input possible values: repeat, endall, pass

• eval (str) – specify when to evaluate expressions possible values: init, frame

• shortest (bool) – force termination when the shortest input terminates

• format (str) – set output format possible values: yuv420, yuv420p10, yuv422, yuv422p10, yuv444, yuv444p10, rgb, gbrp, auto

• repeatlast (bool) – repeat overlay of the last overlay frame

• alpha (str) – alpha format possible values: straight, premultiplied