Enum CompositeOp 

#[non_exhaustive]
pub enum CompositeOp {
    Over,
    Under,
    In,
    Out,
    Atop,
    Xor,
}

Porter-Duff compositing operator for combining two video layers.

Which path renders which operator

Over and Under are built with the overlay filter and are genuine alpha compositing on both paths. In, Out, Atop and Xor render on the GPU compositor only, which implements the W3C / Porter-Duff definitions (#1670). On the filter path they are refused at build time with FilterError::UnsupportedCompositeOp (#1753, ADR-0014): libavfilter has no Porter-Duff filter, blend’s all_expr can only reference the same plane of both inputs, and the composite chain normalises to yuv420p, so the only thing it could compute is per-channel arithmetic wearing the operator’s name. A filter-path implementation that carries alpha through the chain is #1784, which lifts the refusal.

Use is_filter_path_supported to ask before building.

Unlike BlendMode, which is a colour function of two pixels, these are meant to be alpha algebra. There is no blend all_mode token for Porter-Duff compositing, so this type has no FfmpegToken impl; each operator maps to a specific FFmpeg construction (overlay or blend with a per-channel expression) in the filter graph.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Over

Top layer rendered over the bottom (standard alpha compositing).

Built via overlay=format=auto:shortest=1.

Under

Bottom layer rendered over the top; Over with the inputs swapped.

Built via overlay with swapped input order.

In

Top layer masked by the bottom layer’s alpha (intersection).

GPU compositor only; refused on the filter path (see the type docs).

Out

Top layer visible only where the bottom layer is transparent.

GPU compositor only; refused on the filter path (see the type docs).

Atop

Top layer placed atop the bottom; visible only where the bottom is opaque.

GPU compositor only; refused on the filter path (see the type docs).

Xor

Pixels from exactly one layer (XOR of opaque regions).

GPU compositor only; refused on the filter path (see the type docs).

Implementations

impl CompositeOp

pub fn is_filter_path_supported(self) -> bool

Whether the filter (CPU) path can build this operator correctly.

true for Over and Under, which the overlay filter implements as real alpha compositing. false for In, Out, Atop and Xor, which the filter path refuses until #1784 carries alpha through the chain; the GPU compositor renders them. Every filter-path entry point checks this at build time, so a caller only needs it to decide before building, for example to require a GPU compositor up front.

Trait Implementations

impl Clone for CompositeOp

fn clone(&self) -> CompositeOp

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for CompositeOp

impl Debug for CompositeOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CompositeOp

fn default() -> CompositeOp

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CompositeOp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for CompositeOp

impl PartialEq for CompositeOp

fn eq(&self, other: &CompositeOp) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for CompositeOp

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CompositeOp