Alpha compositing
Alpha compositing is a technique in computer graphics for combining two or more images, where an alpha channel associated with each pixel represents its degree of opacity or coverage, enabling transparent or semi-transparent blending of a source image over a destination (background) image to produce a composite result.[1] Introduced in its modern form through the alpha channel concept by Ed Catmull and Alvy Ray Smith in 1978, it was formalized for digital image compositing by Thomas Porter and Tom Duff in their 1984 paper, which defined a set of binary operators like "over," "in," and "out" based on subpixel area contributions.[2][1] The alpha value, typically ranging from 0 (fully transparent, no coverage) to 1 (fully opaque, complete coverage), with fractional values indicating partial coverage for anti-aliasing or soft edges, is often stored as a fourth channel alongside RGB color values in an RGBA format.[1] To optimize computations, colors are premultiplied by the alpha value before compositing, yielding formulas such as for the "over" operator: output color C_o = C_s + (1 - \alpha_s) C_b and output alpha \alpha_o = \alpha_s + (1 - \alpha_s) \alpha_b, where subscripts s and b denote source and background, and C_s, C_b are premultiplied colors.[1][3] This premultiplied approach, a key innovation by Porter and Duff, avoids division artifacts and supports efficient layering in rendering pipelines.[2] Alpha compositing underpins numerous applications in visual media, including pasting foreground objects onto new backgrounds, integrating computer-generated imagery with live-action film footage via matting techniques like blue-screen keying, and layer-based photo editing in software such as Adobe Photoshop for semi-transparent effects or motion blur simulation.[4] Its foundational role extends to standards like the W3C's Compositing and Blending specification, which adopts the Porter-Duff model for web graphics, and to hardware-accelerated rendering in APIs such as OpenGL and Vulkan, making it essential for 2D/3D graphics, animation, and digital filmmaking.[3]Fundamentals
Alpha Channel
The alpha channel is a per-pixel value in digital images that represents the degree of opacity, or conversely transparency, for each pixel, with values typically normalized between 0 (fully transparent) and 1 (fully opaque). In integer representations, such as 8-bit encoding, this corresponds to a range of 0 to 255 levels.[2][5] It is stored as the fourth channel in the RGBA color model, accompanying the red, green, and blue (RGB) channels to form a complete pixel specification that includes both color and transparency information.[6] This integration allows images to carry inherent shape and opacity data without relying on external masks.[2] The term "alpha channel" originated in the 1970s from early video compositing techniques developed at New York Institute of Technology, where Alvy Ray Smith and Ed Catmull coined it to denote the weighting factor α in linear interpolation formulas for blending images, such as αA + (1-α)B.[2] Fundamentally, the alpha channel exhibits grayscale characteristics, with black representing full transparency and white full opacity, and intermediate shades indicating partial translucency; it operates independently of the RGB color channels to define the spatial coverage or matte of image elements.[7][2][8] In contemporary professional graphics workflows, alpha channels often utilize extended precision, such as 16-bit half-floating-point formats in standards like OpenEXR, with 10-bit mantissa precision providing finer gradations than 8-bit integer formats (256 levels) and reduced banding in high-dynamic-range compositing.[9]Purpose and Applications
Alpha compositing primarily enables the layering of semi-transparent graphical elements onto backgrounds without introducing unwanted artifacts, such as halos or incorrect color fringing, by accounting for partial pixel coverage and opacity in 2D graphics, user interface design, and visual effects production.[10] This technique relies on an alpha channel to define transparency per pixel, allowing for realistic overlays where foreground and background colors blend proportionally based on opacity values, which is crucial for maintaining visual fidelity in composite images.[4] In film and visual effects, alpha compositing facilitates the integration of live-action footage with computer-generated elements, such as using chroma keying on green screens to generate alpha mattes that isolate actors for seamless background replacement.[4] For web graphics, it supports transparent image formats like PNG, enabling elements such as logos or icons to overlay page content without opaque backgrounds, as standardized in CSS and SVG through properties likemix-blend-mode for dynamic blending.[3] In video games, alpha compositing is widely applied to particle effects, blending semi-transparent sprites for phenomena like fire, smoke, or explosions into scenes while minimizing overdraw for performance.[11] Modern extensions in augmented reality (AR) and virtual reality (VR) leverage it for real-time blending of virtual objects with live camera feeds, enhancing immersion in applications like Unity-based environments.[12]
The technique offers key benefits, including efficient hardware acceleration through GPU shaders that handle blending operations in parallel, reducing computational overhead compared to CPU-based methods.[12] Additionally, alpha compositing scales effectively across vector-based workflows, such as scalable SVG graphics, and raster formats, maintaining quality from low-resolution UI elements to high-definition renders.[3]
Recent developments since 2020 have integrated alpha compositing with machine learning for advanced image segmentation and AI-generated content, where deep neural networks predict precise alpha mattes to composite synthetic elements onto real images without manual trimaps. For instance, diffusion-based models refine coarse alpha estimates into high-quality mattes for tasks like portrait isolation or environmental effect integration in generative pipelines.[13]
Historical Development
Early Innovations
The concept of the alpha channel emerged in the late 1970s as a solution to challenges in rendering and compositing digital images, particularly for handling partial transparency and anti-aliasing in hidden-surface algorithms. In late 1977 or early 1978, Ed Catmull and Alvy Ray Smith developed the integral alpha channel while working at the New York Institute of Technology's Computer Graphics Laboratory. This innovation integrated a fourth channel—termed "alpha" by Smith to denote coverage or transparency—alongside red, green, and blue (RGBA) in pixel representations, enabling efficient compositing without full re-rendering of scenes. The approach was first documented in Catmull's 1978 paper on a hidden-surface algorithm with anti-aliasing, where alpha facilitated subpixel coverage for smoother edges.[2][14] Early adoption faced significant hardware constraints, as framebuffers capable of supporting 32-bit RGBA pixels were prohibitively expensive—costing around $260,000 in 1975 dollars—and scarce, with only a handful available worldwide. Prior to integral alpha, transparency in digital graphics relied on ad-hoc methods, such as separate matte passes or manual optical compositing in film workflows, which lacked per-pixel precision and required labor-intensive reprocessing. These limitations stemmed from the dominance of 24-bit RGB framebuffers, forcing developers to approximate transparency through binary masks or multiple rendering layers, often resulting in artifacts like jagged edges or inconsistent blending. Smith's reflections highlight how the alpha channel addressed these issues by treating transparency as an inherent pixel property, paving the way for more seamless video compositing.[2][15] A key precursor to formalized alpha compositing appeared in 1981 with Bruce A. Wallace's work on merging and transforming raster images for cartoon animation. Wallace derived a physical model for blending images based on reflectance and transmittance properties, introducing alpha as a coverage factor to interpolate between foreground and background signals accurately. This formulation, applied to video-like raster data, effectively described the "over" operation for partial overlaps, demonstrating practical utility in animation pipelines without dedicated hardware channels. His SIGGRAPH paper emphasized alpha's role in preserving image quality during transformations, influencing subsequent digital effects tools. By the early 1980s, alpha channels entered production environments through systems like the Pixar Image Computer, developed in the early 1980s at Lucasfilm (where Catmull and Smith relocated in 1979), with a prototype demonstrated at SIGGRAPH in 1984 and commercially released in 1986. This hardware incorporated four parallel 12-bit channels for RGB and alpha from the outset, supporting per-pixel transparency in imaging tasks such as visual effects compositing. Lucasfilm's framebuffers were designed as RGBA exclusively, enabling early digital workflows for film and video that integrated alpha for matte generation and layering, marking a shift from analog optical printers to programmable digital solutions.[2][16]Porter-Duff Model
The Porter-Duff model was introduced by Thomas Porter and Tom Duff in their seminal 1984 paper "Compositing Digital Images," presented at SIGGRAPH and published in Computer Graphics. In this work, the authors formalized compositing as a series of set operations performed on rectangular image regions, enabling the systematic combination of digital images with partial transparency.[10] The core concept treats each image as a set of pixels, where every pixel is defined by a color (typically RGB) and a coverage value provided by the alpha channel, representing the fraction of the pixel area occupied by the image's content. Compositing occurs through binary operators applied to the source image (S) and destination image (D) mattes, which are the alpha representations delineating covered versus uncovered areas. This geometric interpretation allows for intuitive handling of overlaps, exclusions, and unions between image regions.[10] The model defines twelve canonical binary operators, each corresponding to a logical combination of source and destination coverage: clear (no coverage), S (source only), D (destination only), S over D, D over S, S in D, D in S, S out D, D out S, S atop D, D atop S, S xor D (exclusive or), and S plus D (union). These are compactly notated using the symbol ◦, as in S ◦ D for source over destination, facilitating both theoretical analysis and practical implementation.[10] This framework quickly became an industry standard for alpha compositing, influencing the development of key graphics tools and APIs; for instance, it underpins layer compositing in Adobe Photoshop (layers introduced in version 3.0 in 1994, building on alpha channel support from version 1.0 in 1990) and serves as the basis for blending functions in OpenGL. Its emphasis on premultiplied alpha and set-based operations revolutionized digital image manipulation, forming the foundation for nearly all modern compositing systems.[2][17]Compositing Operations
Over Operator
The over operator is the most fundamental compositing operation in alpha compositing, which combines a foreground image (source A) with a background image (destination B) by placing A in front of B, blending their contributions proportionally based on their alpha values to simulate occlusion.[10] This operation arises from the Porter-Duff model of compositing as digital images using set-theoretic region operations, where "over" corresponds to the union of the source and destination regions.[10] The resulting alpha coverage for the composite, denoted \alpha_o, is given by the formula \alpha_o = \alpha_a + \alpha_b (1 - \alpha_a), where \alpha_a is the source alpha and \alpha_b is the destination alpha, both in the range [0, 1]. This expression represents the total coverage of the union, accounting for the source fully covering its area while the destination contributes only where the source is transparent. Assuming premultiplied colors, where C_a and C_b represent the source and destination colors scaled by their respective alphas, the composite color C_o is computed directly as the sum of contributions: C_o = C_a + C_b (1 - \alpha_a). [10] This premultiplied approach avoids division and handles fully transparent pixels naturally as zero contributions. This formula assumes a linear color space, where alpha values represent fractional coverage of the pixel area, and colors are blended additively without gamma correction applied during the operation itself.[10] Partial transparency is handled by treating alpha as the proportion of the pixel covered by the opaque source material, enabling proportional blending that preserves the relative contributions.[10] The practical derivation begins at the conceptual level with set theory: consider the source and destination as sets of subpixel regions, where the over operation computes the union of these sets. The source region covers a fraction \alpha_a of the pixel, and the destination covers \alpha_b, but the overlapping portion (where source is opaque) excludes the destination. Thus, the total covered area is the source area plus the destination area outside the source: \alpha_o = \alpha_a + \alpha_b (1 - \alpha_a). For premultiplied colors, the result is the direct sum of contributions from each region's coverage: the source contributes C_a, and the destination contributes C_b (1 - \alpha_a). At the pixel level, this translates directly to the formulas above, assuming uniform color within each coverage fraction and independence across color channels.[10] Edge cases illustrate the operator's behavior: when the source is fully opaque (\alpha_a = 1), \alpha_o = 1 and C_o = C_a, so the result is entirely the source; conversely, when the source is fully transparent (\alpha_a = 0), \alpha_o = \alpha_b and C_o = C_b, preserving the destination unchanged.[10]Other Operators
Beyond the standard over operator, the Porter-Duff model defines several specialized compositing operators that enable precise control over how source and destination images interact, particularly for masking, clipping, and exclusion effects. These operators treat alpha channels as coverage maps, dividing the image plane into regions of source-only, destination-only, and overlap, then selecting or blending based on set-theoretic combinations.[18] The in operator (source in destination) restricts the source image to the shape defined by the destination's alpha channel, effectively clipping the source to the destination's opaque regions. This is useful for confining foreground elements within a predefined boundary, such as embedding text within an irregular shape. Mathematically, assuming premultiplied colors where C_A and C_B represent the source and destination colors scaled by their alphas \alpha_A and \alpha_B, the output is given by: \alpha_o = \alpha_A \alpha_B C_o = C_A \alpha_B In non-overlapping source regions, the result is transparent, while the destination is discarded.[18] Symbolically, it selects the intersection region (A ∩ B) with source color, discarding A - B and retaining nothing from B. The out operator (source out of destination) extracts the source image from outside the destination's shape, creating punch-out or knockout effects where the destination carves holes in the source. This is ideal for revealing underlying layers through subtracted areas, like creating vignettes or irregular frames. The formulas are: \alpha_o = \alpha_A (1 - \alpha_B) C_o = C_A (1 - \alpha_B) The destination is entirely discarded, and the output is transparent where the source overlaps the destination.[18] In set terms, it yields A - B, with no contribution from the intersection or B alone. The atop operator (source atop destination) places the source content only within the destination's shape while preserving the destination's color outside the source, functioning as a masking operation that replaces the destination's interior with the source. This is commonly used for cookie-cutter effects or integrating elements seamlessly into a base layer's silhouette. The expressions simplify to: \alpha_o = \alpha_B C_o = C_A \alpha_B + C_B (1 - \alpha_A) The overall coverage matches the destination, but colors blend source in the overlap and destination elsewhere.[18] Regionally, it combines (A ∩ B with source color) union (B - A with destination color). The xor operator (exclusive or) reveals non-overlapping portions of both source and destination, excluding their intersection to produce mutual exclusion effects. This is valuable for toggling visibility between layers without overlap blending, such as alternating reveals in animations or UI elements. The formulas are: \alpha_o = \alpha_A (1 - \alpha_B) + \alpha_B (1 - \alpha_A) C_o = C_A (1 - \alpha_B) + C_B (1 - \alpha_A) No contribution comes from the overlap, resulting in transparency there.[18] Set-wise, it outputs (A - B) union (B - A). These operators find niche applications in image editing software for advanced matte operations. For instance, in GIMP, compositing modes implement equivalents of in, out, atop, and xor to handle layer masking and selection without color blending, allowing precise control over transparency in non-destructive workflows. Similarly, Adobe After Effects employs track mattes that leverage these principles for luma- or alpha-based clipping and exclusion in video compositing, enabling effects like traveling mattes for dynamic reveals.[19] Brief symbolic diagrams often illustrate them as Venn diagrams: in covers the overlap with source; out shades source excluding overlap; atop fills destination with source in overlap; xor highlights symmetric differences.Alpha Representation Methods
Straight Alpha
Straight alpha, also known as unassociated alpha, is a representation in which the RGB color components store the true, unscaled scene colors normalized to a 0-1 range, while the separate alpha channel provides an independent opacity multiplier for blending.[2] For example, a pixel with values (0.8, 0.2, 0.4, 0.5) indicates a color of 80% red, 20% green, and 40% blue, visible at 50% opacity without any scaling applied to the RGB values.[2] This approach offers advantages in editing workflows, as the color values remain unaltered by transparency adjustments, preserving the original scene hues for intuitive modifications.[20] It is commonly used in image acquisition from cameras and scanners, where RGB data captures unmultiplied colors and alpha is added later for compositing purposes.[20] Straight alpha is typically stored in file formats supporting independent channels with full precision, such as uncompressed TIFF, where RGB and alpha are maintained as separate components, often at 8 bits per channel or higher to avoid quantization errors.[21] In compositing pipelines, RGB values are multiplied by the alpha channel only at the blending stage—such as in the over operator—to generate the final output, after which the result may be converted and stored in premultiplied form for subsequent operations.[2]Premultiplied Alpha
Premultiplied alpha, also known as associated alpha, represents a pixel's color components (R, G, B) as values already scaled by the alpha value (A), where A denotes the opacity or coverage fraction ranging from 0 (fully transparent) to 1 (fully opaque).[18] In this format, the stored quadruple (r, g, b, a) corresponds to an effective color of (r/a, g/a, b/a) at opacity a, assuming a > 0.[18] For example, a pixel stored as (0.4, 0.1, 0.2, 0.5) implies an effective color of (0.8, 0.2, 0.4) at 50% opacity, since each color channel is the product of the true color and the alpha value.[22] This representation was introduced by Thomas Porter and Tom Duff in their 1984 paper on compositing digital images, specifically to facilitate efficient matting and blending operations in image synthesis systems.[18] It has since become a standard in video compositing workflows and 3D rendering pipelines, such as those in OpenGL, where hardware-accelerated blending relies on premultiplied values for optimal performance.[18] To convert from straight (unassociated) alpha, where color channels are independent of alpha, the premultiplied channels are computed as: \begin{align*} R_{\text{pre}} &= R_{\text{straight}} \times \alpha, \\ G_{\text{pre}} &= G_{\text{straight}} \times \alpha, \\ B_{\text{pre}} &= B_{\text{straight}} \times \alpha, \end{align*} with the alpha channel unchanged.[3] Recovery of straight alpha requires division: R_{\text{straight}} = \frac{R_{\text{pre}}}{\alpha}, \quad G_{\text{straight}} = \frac{G_{\text{pre}}}{\alpha}, \quad B_{\text{straight}} = \frac{B_{\text{pre}}}{\alpha}, provided \alpha > 0; otherwise, the color is undefined or treated as black.[18][3] A key advantage of premultiplied alpha is its computational efficiency in blending operations, as it eliminates the need for per-channel multiplications and divisions during compositing. For the over operator, which places the source image atop the destination, the output color C_o and alpha \alpha_o simplify to direct addition without scaling the source color: C_o = C_a + C_b (1 - \alpha_a), \quad \alpha_o = \alpha_a + \alpha_b (1 - \alpha_a), where C_a and C_b are the premultiplied source and destination colors, respectively.[18] This form enables faster execution in GPU shaders and fixed-function blending units, such as OpenGL'sglBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA), avoiding division operations and potential clamping of intermediate values exceeding the [0,1] range.[23]
Regarding precision, premultiplication reduces the effective dynamic range for color channels, particularly at low alpha values, as the scaled values occupy fewer distinct levels in fixed-point representations like 8-bit per channel. For instance, in an 8-bit RGBA format, premultiplication can map multiple input colors to the same output, effectively wasting about 2 bits of precision and reducing unique color-alpha combinations to roughly 25% of the total possible.[22] This trade-off is largely mitigated in modern pipelines using higher bit depths, such as 16-bit floating-point formats, which preserve sufficient precision for most applications without significant loss.[22][18]
Comparison and Examples
Straight alpha preserves the original color values of pixels independently of their opacity, making it ideal for editing and manipulation where color fidelity is crucial, such as in image authoring tools.[24] In contrast, premultiplied alpha multiplies the RGB components by the alpha value during storage, which excels in rendering pipelines involving repeated blending operations, as it supports efficient and associative compositing for multiple layers.[25] A practical example illustrates the equivalence in final output despite differing storage. Consider blending a semi-transparent red circle (RGB = 1,0,0; α = 0.5 in straight alpha, or premultiplied RGB = 0.5,0,0; α = 0.5) over a white background (RGB = 1,1,1; α = 1). Using the over operator, the result for both is an intermediate pink (RGB ≈ 1, 0.5, 0.5; α = 1), demonstrating identical visual outcomes when properly interpreted, though the premultiplied version stores scaled colors to facilitate efficient hardware blending.[22] Converting between representations introduces pitfalls, particularly when recovering straight alpha from premultiplied data, which requires dividing RGB values by alpha; this operation is undefined (division by zero) for fully transparent pixels where α = 0, potentially leading to artifacts or requiring special handling like clamping to zero RGB.[22] Tools such as Adobe After Effects provide options like "Interpret Footage" to specify and switch alpha types during import, mitigating mismatches, while applications like Substance Designer offer dedicated nodes for straight-to-premultiplied conversion.[24][26] Best practices recommend using straight alpha for source images and vector formats, where editing flexibility is prioritized—SVG, for example, employs straight alpha in its color specifications like rgba() to maintain unassociated color data.[27] Premultiplied alpha is preferred for final rendering and compositing workflows to avoid interpolation errors during effects like blurring.[24] In modern contexts, GPU APIs such as WebGL favor premultiplied alpha for performance, as it aligns with hardware-accelerated bilinear filtering and blending modes, reducing shader computations and preventing fringing artifacts in texture sampling.[28]Technical Challenges
Gamma Correction
Gamma encoding is a non-linear transformation applied to color values in common image formats like sRGB, where the encoded color component C_e relates to the linear light intensity C_\text{linear} by C_e = C_\text{linear}^{1/\gamma} with \gamma \approx 2.2. This encoding optimizes storage and display for human perception but requires reversal before compositing operations, as alpha blending assumes linear light intensities to accurately model physical light accumulation. Performing blends directly on encoded values leads to visually incorrect results, such as washed-out appearances in bright areas or excessively dark tones in shadows.[29] To adapt the over operator for gamma-encoded inputs using premultiplied alpha, the premultiplied encoded colors are first linearized: C_{a,\text{pre,lin}} = C_{a,\text{pre,e}}^\gamma and C_{b,\text{pre,lin}} = C_{b,\text{pre,e}}^\gamma, where C_{a,\text{pre,e}} and C_{b,\text{pre,e}} are the encoded premultiplied values. The premultiplied linear output color is computed as C_{o,\text{pre,lin}} = C_{a,\text{pre,lin}} + C_{b,\text{pre,lin}} (1 - \alpha_a), with the output alpha \alpha_o = \alpha_a + \alpha_b (1 - \alpha_a). The result is then re-encoded for display: C_{o,\text{pre,e}} = C_{o,\text{pre,lin}}^{1/\gamma}. Notably, the alpha channel itself remains linear and is not gamma-corrected, as it represents coverage or opacity proportionally.[30] Incorrect blending in non-linear space distorts the perceptual uniformity of transparency, often producing halo artifacts—such as dark fringes or color shifts—around semi-transparent edges due to improper intensity weighting. These issues arise because gamma-encoded values do not add linearly, leading to biased accumulation of light contributions.[29] Solutions include software controls for explicit linearization, such as Adobe Photoshop's "Blend RGB Colors Using Gamma 1.0" option, which switches layer blending to linear RGB space for more accurate composites under normal and similar modes. On the hardware side, modern GPUs support linear blending through sRGB texture formats and framebuffer attachments (e.g., via OpenGL'sGL_SRGB or DirectX equivalents), which automatically decode inputs to linear space before blending and encode outputs afterward.[31][32]
A practical example is compositing a semi-transparent gradient overlay onto a colorful background image: without gamma correction, the blend appears desaturated and low-contrast, with mid-tones losing vibrancy; in contrast, linear-space processing preserves the gradient's intended smoothness and the underlying image's dynamic range, yielding a more natural integration.[33]
File Format Support
Alpha compositing relies on file formats that can store alpha channels to preserve transparency information during image and video handling. Raster image formats like PNG natively support alpha channels with straight alpha encoding, allowing up to 16 bits per channel for RGB and alpha, which enables high-fidelity transparency for web and general graphics applications with universal browser support across Chrome, Firefox, Safari, and Edge. TIFF, commonly used in professional workflows such as photography and printing, accommodates 32-bit depth (8 bits per channel for RGBA) and supports both straight and premultiplied alpha, facilitating advanced compositing in tools like Adobe Photoshop. Vector formats integrate alpha for scalable transparency without pixel loss. SVG employs straight alpha through opacity attributes, achieving an effective 32-bit depth equivalent via floating-point values, making it ideal for web graphics and animations that require resolution independence. PDF, starting from version 1.4, embeds alpha channels within transparency groups to handle layered compositing, supporting professional document creation and print workflows with broad software compatibility.[34] Video formats extend alpha support for motion graphics and effects. QuickTime with HEVC (H.265) provides 8- to 10-bit alpha channels, enabling efficient encoding for professional video editing in applications like Final Cut Pro, with strong macOS and iOS integration.[35] WebM using VP9 codec offers 12-bit alpha depth, suitable for web-based transparent videos, with improved browser support in Chrome and Firefox by 2025, though Safari adoption remains partial. AVIF, an emerging format since 2023 based on AV1, delivers 10- to 12-bit alpha for compact web images and videos, achieving full support in all major browsers by 2025 for enhanced efficiency in responsive designs.[36]| Format | Max Depth (per channel) | Alpha Type | Common Uses | Browser/OS Support (2025) |
|---|---|---|---|---|
| PNG | 16-bit | Straight | Web graphics, icons | Universal (all major browsers, all OS) |
| TIFF | 32-bit (8-bit RGBA) | Straight & Premultiplied | Professional editing, archiving | N/A (desktop apps: Windows, macOS, Linux) |
| SVG | 32-bit effective | Straight | Scalable web/UI elements | Universal (all major browsers, all OS) |
| Varies (up to 32-bit) | Embedded (straight) | Documents, print compositing | Universal (Adobe Reader, all OS) | |
| QuickTime/HEVC | 10-bit | Varies | Video editing, motion graphics | macOS/iOS full; Windows partial |
| WebM/VP9 | 12-bit | Varies | Web videos, animations | Chrome/Firefox full; Safari partial |
| AVIF | 12-bit | Straight | Web images/videos | Full (all major browsers, all OS) |