Image engine (EngineImage)
Engine id image — raster images only. SVG and PDF belong to other engines; no svg or pdf path is declared here.
State of this document: 2026-11-21, measured on the build machine (Apple M5 Max, 18 cores, 48 GB, macOS 27.0, Swift 6.4.2). "Supported" means implemented, tested and passing on that machine on that day.
- Package:
Packages/EngineImage(moduleEngineImage, factorymakeEngines()), depends on../ORIXConvertCoreand on the binary targetCWebP(EmbeddedEngines/libwebp/CWebP.xcframework, built byEmbeddedEngines/libwebp/build.sh). - Tests:
swift testfromPackages/EngineImage— 54 tests in 10 suites, all passing (the two parameterised matrix tests alone run the 443 declared paths). - Core contract: no change, nothing added.
1. What does the work
| Task | Component |
|---|---|
| Decoding | ImageIO for everything it reads; own strict readers for Netpbm (P1–P6) and Radiance RGBE |
| Encoding | ImageIO (PNG, APNG, JPEG, HEIC/HEIF, AVIF, TIFF, BMP, GIF, ICNS, PSD, EXR, TGA, JPEG 2000); bundled libwebp 1.6.0 (WebP lossy, lossless, alpha, animation, ICC/EXIF/XMP chunks); own writers for Netpbm, Radiance RGBE and ICO |
| Exact geometry | own pixel permutations (EXIF orientation, 90° turns, flips), CGImage.cropping |
| Resampling, free rotation, watermark | Core Image, CILanczosScaleTransform, extended linear sRGB working space (linear light) |
| Colour and depth conversion | vImage / ColorSync (vImageBuffer_InitWithCGImage with the target profile); Core Image when a Core Image stage runs anyway |
| HDR → SDR | own hue-preserving tone curve on linear floats (see §4) |
| Background removal | Vision VNGenerateForegroundInstanceMaskRequest (on-device system model) |
| PNG optimisation | lossless reductions + IDAT recompression with the system zlib (level 9, three strategies) |
| Verification | ImageIO re-decode, libwebp re-decode for WebP, SHA-256 of pixels for lossless encoders, PSNR for lossy ones |
Formats are taken from CGImageSourceCopyTypeIdentifiers() / CGImageDestinationCopyTypeIdentifiers() when the
process starts; a format ImageIO does not list is not declared. On this Mac ImageIO does not write WebP,
Radiance HDR, JPEG XL or DNG, refuses AVIF at quality 1.0, refuses more than six images in an ICO (hence the own
ICO writer), and writes ICNS only at 16, 32, 48, 128, 256, 512 px plus 64 and 1024 px when tagged 144 dpi (@2x).
All synchronous work runs on the engine's own concurrent dispatch queue, never on Swift's cooperative pool: the
AVIF encoder of macOS blocks while waiting for its worker threads and deadlocks a saturated cooperative pool
(found by the matrix test). At most activeProcessorCount conversions run at once inside the engine.
2. Order of operations
decode (pixels are taken once, eagerly) → EXIF orientation → crop → 90° turns → flips → background removal → free rotation → resize → watermark → HDR tone mapping → colour profile / bit depth → alpha flattening → grayscale → icon representations → encode → re-read metadata → decode the written file and compare.
When nothing but the container changes, the decoded CGImage is handed to the encoder untouched: no resampling,
no colour conversion, no copy through Core Image.
3. Options (keys of ConversionOptions)
| Group | Keys |
|---|---|
| Quality | quality (1–100), target.size-kb (binary search on quality, every candidate really encoded and measured), lossless (WebP, JPEG 2000), webp.method (0–6), jpeg.progressive, png.effort (0–2), tiff.compression (none, lzw, packbits, deflate), pnm.plain |
| Size | resize.mode (none, fit, fill, exact, percent, long-edge), resize.width, resize.height, resize.percent, resize.long-edge, resize.upscale, crop.mode (none, rect, aspect), crop.x, crop.y, crop.width, crop.height, crop.aspect, rotate.angle (clockwise; multiples of 90° are exact), flip.horizontal, flip.vertical, orientation.normalize, icon.sizes, page |
| Colour | color.profile (keep, srgb, display-p3, adobe-rgb, gray), color.depth (auto, 8, 16, float — only what the destination stores), background.color, background.remove |
| Metadata | metadata (keep, strip-location, strip) |
| Animation | animation.loop |
| Watermark | watermark.text, watermark.image, watermark.position (9 anchors), watermark.opacity, watermark.scale, watermark.margin, watermark.color |
| Safety | limit.megapixels (default 400), verify.measure (default on) |
Named operation: image.optimize on png→png (lossless, png.effort 2 by default), jpeg→jpeg and webp→webp
(re-encoding; lossy unless WebP lossless). Same-format paths (png→png, jpeg→jpeg…) carry resize, crop,
metadata stripping and every other option.
4. Behaviour that must be known
Lossless. A path is declared lossless when the encoder stores exactly what it is given and the destination
can hold the source's alpha and depth. For those encoders (PNG, APNG, TIFF, BMP, TGA, PPM, PGM, PBM, lossless WebP
stills, lossless JPEG 2000) the conversion fails with outputInvalid if the written file does not decode to the
same samples, and validate re-checks a SHA-256 of the decoded pixels. The matrix test additionally compares
the decoded source with the decoded output for every lossless path.
Lossy. psnr.db in ConversionOutput.facts is measured between the pixels handed to the encoder and the
decoded file (worst frame for animations; R, G, B — alpha-premultiplied R, G, B and alpha when there is
transparency). It is not a quality score and nothing is estimated.
Colour. Embedded ICC profiles are kept when the destination embeds one (PNG, JPEG, HEIC/HEIF, AVIF, TIFF, PSD,
WebP). BMP, GIF, ICO, ICNS, TGA, Netpbm and JPEG 2000 output is converted to sRGB (profile-converted, or
gamut-reduced with severity data-loss when the source is wide-gamut). EXR and Radiance output is linear with
sRGB / Rec. 709 primaries. Known values checked in tests: sRGB red → Display P3 (234, 51, 35); sRGB green →
Adobe RGB (144, 255, 60); sRGB red → gray 2.2 = 127; P3 red → sRGB (255, 0, 0) with the warning.
Alpha. Transparency going into a format without alpha is composited over background.color in the encoded
values of the output colour space (what a browser shows), with alpha-flattened (data-loss) — only when a pixel
really is transparent. GIF keeps on/off transparency only (gif-palette).
Bit depth. 16-bit → 8-bit warns bit-depth-reduced. HEIC, HEIF and AVIF store 10 bits when given 16.
JPEG 2000 through ImageIO stores 8 bits.
HDR. Float sources (EXR, Radiance, float TIFF) and PQ/HLG sources written to an SDR format are tone-mapped:
linear values up to 0.5 are untouched; above, the largest component of each pixel is compressed by a rational
curve that sends the measured peak to 1.0, the three components scaled together. hdr-tone-mapped (data-loss)
states the measured peak. Core Image's CIToneMapHeadroom was evaluated and rejected: it works on luminance and
clipped saturated highlights in the test ramp. HDR → EXR / Radiance / float TIFF keeps the values (no warning).
Gain-map HEIC: SDR destinations get Apple's SDR rendition with hdr-gain-map-dropped; float destinations are
decoded with kCGImageSourceDecodeToHDR. Writing HDR HEIC/AVIF (PQ or gain map) is not implemented.
Metadata. Copied with CGImageMetadata (EXIF, TIFF, GPS, IPTC, XMP). strip-location removes every
exif:GPS* tag and the IPTC/XMP city, state, country and location fields. After writing, the file is re-read:
metadata.exif, metadata.gps, metadata.iptc, metadata.xmp, metadata.icc are what is really there;
metadata-dropped (data-loss) names what the destination did not keep; a strip or strip-location request
whose result still contains the data fails with outputInvalid instead of delivering the file. WebP EXIF/XMP
chunks are serialised by ImageIO (through a throw-away JPEG) and attached with libwebpmux.
Animation. GIF ↔ APNG ↔ animated WebP keep frames, delays and loop count (validate checks duration within
11 ms per frame, and the loop count). Animated → still keeps the first frame with animation-first-frame.
All frames are held in memory; the pixel limit applies to their sum.
TIFF pages. TIFF → TIFF keeps every page; elsewhere the first page (or page) with pages-first-page.
Icons. ICO: 16, 24, 32, 48, 64, 128, 256; ICNS: 16, 32, 64, 128, 256, 512, 1024 — the standard sizes not larger
than the source (never an enlargement unless the source is smaller than the smallest size), each fitted in a
transparent square, Lanczos-resampled. Reading an icon takes its largest representation
(icon-largest-representation).
RAW / DNG. Decode-only, Apple's default rendering through ImageIO (16-bit Display P3 on this Mac); no development controls. See §7 for what could be tested.
Safety. The pixel count is checked from the header before decoding (limitExceeded, default 400 MP, sum of
frames for animations). Netpbm and Radiance lengths are verified against the real file size before any
allocation. Truncated files are refused: ImageIO's status, an eager pixel fetch, and container checks where
ImageIO zero-fills silently (PNG/APNG IEND, GIF trailer, BMP data length, ICNS length). Sources above 64 MP (or
above the limit) whose requested output is at most half their size are decoded subsampled by ImageIO
(subsampled-decode, fact decode.subsample); that first reduction is not done in linear light, which is why it
is reserved for very large sources. Cancellation is checked between stages, per frame, per scanline block in the
own codecs, and inside libwebp through its progress hook; no partial output is left.
Preflight (from the inspection, before converting): alpha-flattened, animation-first-frame,
pages-first-page, hdr-tone-mapped, hdr-gain-map-dropped, bit-depth-reduced, gamut-reduced,
metadata-dropped, dimension-limit (WebP 16383 px, JPEG 65535 px), pixel-limit, upscaled, gif-palette,
icon-resampled, raw-default-rendering, bilevel-threshold, invalid-option.
Validate: decodes, dimensions (computed from the source inspection and the options, not from the
conversion's own report), frame count, format limit, alpha, animation timing, loop count, pixels.
Quality Lab API: ImagePreview.decode(url:maxPixelSize:frame:) (upright, bounded) and
ImageComparison.compare(_:_:matchingColorSpaces:) / compare(fileA:fileB:maxPixelSize:) returning
PixelDifference (identical, identical where visible, PSNR, largest difference, differing pixels).
5. Measured performance
Machine: Apple M5 Max, 18 cores, 48 GB, macOS 27.0, release build. The machine was shared and heavily loaded
during the runs (1-minute load average between 35 and 99 on 18 cores), so these are lower bounds, not best
cases. 200 generated pictures of 4000 × 3000 (12 MP, smooth structures + edges + fine grain; 3157 MB of PNG).
Command: EngineImageBench prepare <dir> 200, then one process per line (EngineImageBench run …), so the peak
resident size belongs to that scenario. "Verify" is the engine's own decode-and-compare of every written file
(on by default).
| Scenario | Concurrency | Verify | Wall time | Images/s | MP/s | Peak RSS | Output | Measured PSNR |
|---|---|---|---|---|---|---|---|---|
| PNG → JPEG (q 85) | 18 | on | 9.76 s | 20.5 | 246 | 3917 MB | 612.8 MB | 42.43 dB mean, 42.42 min |
| PNG → JPEG (q 85) | 18 | off | 5.33 s | 37.5 | 450 | 2444 MB | 612.8 MB | — |
| PNG → JPEG (q 85) | 1 | off | 60.33 s | 3.3 | 40 | 158 MB | 612.8 MB | — |
| PNG → JPEG, long edge 2048 (Lanczos) | 18 | off | 15.42 s | 13.0 | 156 | 2494 MB | 90.4 MB | — |
| PNG → WebP (q 80, method 4) | 18 | on | 24.39 s | 8.2 | 98 | 4992 MB | 44.6 MB | 38.73 dB mean, 38.66 min |
| PNG → WebP (q 80, method 4) | 18 | off | 16.10 s | 12.4 | 149 | 4845 MB | 44.6 MB | — |
| PNG → HEIC (q 80) | 18 | on | 23.38 s | 8.6 | 103 | 3976 MB | 589.1 MB | 44.05 dB mean, 43.92 min |
| HEIC → JPEG (q 85) | 18 | on | 9.19 s | 21.8 | 261 | 1921 MB | 595.8 MB | 42.70 dB mean, 42.62 min |
| HEIC → JPEG (q 85) | 18 | off | 9.58 s | 20.9 | 251 | 2262 MB | 595.8 MB | — |
Notes: generating the 200 PNG sources took 21.1 s. The two HEIC → JPEG lines differ by less than the noise of the loaded machine. The benchmark was not repeated; no variance is claimed. PNG effort on one 400 × 300 test image (16-bit container, opaque alpha): 7767 bytes at effort 0, 3968 at effort 1, 1887 at effort 2, pixels identical.
6. Tests
swift test in Packages/EngineImage: ✔ Test run with 54 tests in 10 suites passed.
Fixtures are generated in code at test time: ImageIO for the formats it writes, hand-written bytes for Netpbm, Radiance and a linear-raw DNG 1.4 (own minimal TIFF writer), libwebp for the animated WebP. Nothing is downloaded.
| Suite | What it checks |
|---|---|
| Declared path matrix | every declared path (440 conversions + 3 operations): convert, validate, facts; pixel-exact source ↔ output for lossless paths; PSNR for lossy ones; alpha, animation, metadata and ICC claims |
| Lossless round-trips | PNG → TIFF → PNG, 16-bit, Display P3 kept, lossless WebP / JPEG 2000, grayscale |
| Unusual sources | CMYK JPEG, indexed PNG, RAW path on the DNG fixture |
| Geometry | 8 resize cases, linear-light check (checkerboard → 188, not 128), crop, turns, flips, free rotation, EXIF orientation applied / kept |
| Colour, depth and HDR | known colour values, gamut warning, depth reduction / promotion / 10-bit HEIC, EXR and Radiance tone mapping, PQ HEIC, gain-map HEIC |
| Alpha, animation, pages and icons | flatten values and warning, GIF → APNG → WebP → GIF, first frame, TIFF pages, ICO / ICNS |
| Metadata | keep / strip-location / strip on 7 destinations, metadata from 6 source formats, dropped-metadata warning, inspection fields |
| Encoders | target size (JPEG, WebP, HEIC), PNG effort, progressive JPEG and measured subsampling, TIFF compressions, plain Netpbm, watermarks, Vision background removal |
| Untrusted input and limits | 19 formats truncated at 50 % and 15 %, garbage, giant headers, pixel limit and subsampled decode, WebP 16383 px, cancellation (before, during, inside libwebp), 48 concurrent conversions, tampered output, option descriptors, a real PSD from /System/Library |
| Own codecs and Quality Lab API | Netpbm P1–P6, Radiance writer vs ImageIO, PNG recompression, comparison maths, previews |
Three tests print a NOTE: line instead of failing when the system cannot produce their fixture or model. On the
build machine all three ran for real: the PQ HEIC and the gain-map HEIC fixtures were written by Core Image, and
Vision's subject lifting isolated the synthetic subject.
7. Evaluated and not implemented, or limited
| Item | Status | Why |
|---|---|---|
JPEG XL (jxl) as a source |
not declared (inspection only, untested) | ImageIO reads it but nothing on the system writes it, so no fixture can be generated and no path can be tested. Bundling libjxl was not justified for this pass |
| JPEG XL as a destination | not supported | ImageIO does not write it |
Camera RAW (raw) |
declared experimental | no manufacturer RAW file exists on the build machine and none was downloaded. The 20 raw paths are exercised with the DNG fixture passed as raw (same ImageIO decoder entry point); real CR2/CR3/NEF/ARW… files are untested |
| DNG | declared experimental | tested only with a linear-raw (demosaiced) DNG generated in code. A mosaiced (CFA) DNG generated the same way is rejected by Apple's decoder, and so is the same linear DNG at 128 × 96 instead of 256 × 192; camera DNGs are untested |
| RAW / DNG as destinations | not supported | ImageIO does not write them; writing RAW is out of scope |
| RAW development controls | not implemented | only Apple's default rendering |
| JPEG chroma subsampling choice | not available | ImageIO exposes no public control. The subsampling actually written is read from the file and reported (jpeg.subsampling) |
| Lossless JPEG optimisation (Huffman / jpegtran-style) | not implemented | image.optimize on JPEG re-encodes, and says so |
| HDR output to HEIC / AVIF (PQ, HLG, gain map) | not implemented | HEIC/AVIF output is SDR, 8 or 10 bit |
| JPEG 2000 deeper than 8 bit, or with an embedded profile | not available | ImageIO reduces to 8 bit and falls back to sRGB |
| PSD layers | not read, not written | ImageIO returns the flattened composite and writes a flat file; 8-bit transparency is stored premultiplied. Tested with ImageIO-written PSDs and one real PSD from /System/Library |
| AVIF at quality 100 | capped at 99 | ImageIO refuses quality 1.0 |
| Animated AVIF / HEIC sequences as destinations | not implemented | read as animations, not written |
| Animated → multi-page TIFF, TIFF pages → animation | not implemented | first frame / first page only, with a warning |
| Radiance variants (XYZE, flipped scanline orders) | left to ImageIO | the own strict reader covers -Y h +X w RGBE only; for the other variants truncation detection is whatever ImageIO provides (untested) |
| GIF palette control, dithering options | not implemented | ImageIO's quantiser is used as is |
| PBM dithering | not implemented | 50 % threshold only, with a data-loss warning |
| Palette (indexed) PNG output | not implemented | png.effort drops unused alpha and unused 16-bit precision and recompresses; it does not build palettes |
| Watermark tiling / rotation | not implemented | one text or one image, nine anchors |
| Tiled / streaming processing of images larger than memory | not implemented | very large sources are decoded subsampled when a smaller output is asked; otherwise the pixel limit refuses them |
8. Known defects and caveats
- Free rotation uses Core Image's affine transform (bilinear sampling), not Lanczos.
- On HDR → SDR conversions the watermark is composited before tone mapping, so a watermark brighter than half of SDR white is slightly compressed with the highlights.
- The subsampled decode of very large sources is ImageIO's reduction (not linear light); measured agreement with the full pipeline on a smooth 12 MP test picture is above 35 dB, lower on fine periodic detail.
- Truncation of TGA (RLE), PSD, EXR, HEIC, AVIF, TIFF, JPEG, JPEG 2000 and DNG relies on ImageIO failing to deliver pixels; the 50 % and 15 % cuts of the test fixtures are all refused, other damage patterns may decode partially.
- A GIF that does not end with its trailer byte is refused as truncated even if a lenient viewer would show it.
verify.measureroughly halves PNG → JPEG throughput (see §5);validatedecodes the output once more.- The benchmark numbers were taken once, on a loaded machine.
9. Declared paths
443 paths: 22 sources (png, apng, jpeg, heic, heif, webp, avif, tiff, bmp, gif, ico, icns, psd, exr, hdr, tga, ppm,
pgm, pbm, jp2, dng, raw) × 20 destinations (png, apng, jpeg, heic, heif, webp, avif, tiff, bmp, gif, ico, icns,
psd, exr, hdr, tga, ppm, pgm, pbm, jp2) + 3 image.optimize operations. 403 supported, 40 experimental (dng and
raw sources); 80 lossless, 363 lossy. Generated with EngineImageBench paths; every row is converted and
validated by the named test (Tests/EngineImageTests/MatrixTests.swift).
| Source | Destination | Operation | Status | Fidelity | Preserves | Limitations | Test |
|---|---|---|---|---|---|---|---|
| png | png | — | supported | lossless | colorProfile, dimensions, metadata, transparency | MatrixTests.everyPath | |
| png | apng | — | supported | lossless | colorProfile, dimensions, transparency | EXIF, IPTC and XMP metadata are not written. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| png | jpeg | — | supported | lossy | colorProfile, dimensions, metadata | Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| png | heic | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| png | heif | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| png | webp | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| png | avif | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| png | tiff | — | supported | lossless | colorProfile, dimensions, metadata, transparency | MatrixTests.everyPath | |
| png | bmp | — | supported | lossy | dimensions, transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| png | gif | — | supported | lossy | dimensions, transparency | GIF stores at most 256 colours per frame and on/off transparency. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| png | ico | — | supported | lossy | transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| png | icns | — | supported | lossy | transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| png | psd | — | supported | lossy | colorProfile, dimensions, transparency | EXIF, IPTC and XMP metadata are not written. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| png | exr | — | supported | lossy | dimensions, transparency | Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| png | hdr | — | supported | lossy | dimensions | HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| png | tga | — | supported | lossy | dimensions, transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| png | ppm | — | supported | lossy | dimensions | PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| png | pgm | — | supported | lossy | dimensions | PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| png | pbm | — | supported | lossy | dimensions | PBM has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| png | jp2 | — | supported | lossy | dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| apng | png | — | supported | lossless | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. | MatrixTests.everyPath |
| apng | apng | — | supported | lossless | animation, colorProfile, dimensions, transparency | MatrixTests.everyPath | |
| apng | jpeg | — | supported | lossy | colorProfile, dimensions | Animated sources: only the first frame is kept. Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| apng | heic | — | supported | lossy | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| apng | heif | — | supported | lossy | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| apng | webp | — | supported | lossy | animation, colorProfile, dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| apng | avif | — | supported | lossy | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| apng | tiff | — | supported | lossless | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. | MatrixTests.everyPath |
| apng | bmp | — | supported | lossy | dimensions, transparency | Animated sources: only the first frame is kept. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| apng | gif | — | supported | lossy | animation, dimensions, transparency | GIF stores at most 256 colours per frame and on/off transparency. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| apng | ico | — | supported | lossy | transparency | Animated sources: only the first frame is kept. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| apng | icns | — | supported | lossy | transparency | Animated sources: only the first frame is kept. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| apng | psd | — | supported | lossy | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| apng | exr | — | supported | lossy | dimensions, transparency | Animated sources: only the first frame is kept. Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| apng | hdr | — | supported | lossy | dimensions | Animated sources: only the first frame is kept. HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| apng | tga | — | supported | lossy | dimensions, transparency | Animated sources: only the first frame is kept. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| apng | ppm | — | supported | lossy | dimensions | Animated sources: only the first frame is kept. PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| apng | pgm | — | supported | lossy | dimensions | Animated sources: only the first frame is kept. PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| apng | pbm | — | supported | lossy | dimensions | Animated sources: only the first frame is kept. PBM has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| apng | jp2 | — | supported | lossy | dimensions, transparency | Animated sources: only the first frame is kept. Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| jpeg | png | — | supported | lossless | colorProfile, dimensions, metadata | MatrixTests.everyPath | |
| jpeg | apng | — | supported | lossless | colorProfile, dimensions | EXIF, IPTC and XMP metadata are not written. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| jpeg | jpeg | — | supported | lossy | colorProfile, dimensions, metadata | Lossy compression; the PSNR of the result is measured. Largest side: 65535 pixels. | MatrixTests.everyPath |
| jpeg | heic | — | supported | lossy | colorProfile, dimensions, metadata | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| jpeg | heif | — | supported | lossy | colorProfile, dimensions, metadata | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| jpeg | webp | — | supported | lossy | colorProfile, dimensions, metadata | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Largest side: 16383 pixels. | MatrixTests.everyPath |
| jpeg | avif | — | supported | lossy | colorProfile, dimensions, metadata | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| jpeg | tiff | — | supported | lossless | colorProfile, dimensions, metadata | MatrixTests.everyPath | |
| jpeg | bmp | — | supported | lossless | dimensions | No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| jpeg | gif | — | supported | lossy | dimensions | GIF stores at most 256 colours per frame and on/off transparency. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| jpeg | ico | — | supported | lossy | — | No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| jpeg | icns | — | supported | lossy | — | No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| jpeg | psd | — | supported | lossy | colorProfile, dimensions | EXIF, IPTC and XMP metadata are not written. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| jpeg | exr | — | supported | lossy | dimensions | Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| jpeg | hdr | — | supported | lossy | dimensions | Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| jpeg | tga | — | supported | lossless | dimensions | No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| jpeg | ppm | — | supported | lossless | dimensions | No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| jpeg | pgm | — | supported | lossy | dimensions | No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| jpeg | pbm | — | supported | lossy | dimensions | No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| jpeg | jp2 | — | supported | lossy | dimensions | Lossy by default (a lossless mode is available); the PSNR of the result is measured. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| heic | png | — | supported | lossless | colorProfile, dimensions, metadata, transparency | MatrixTests.everyPath | |
| heic | apng | — | supported | lossless | colorProfile, dimensions, transparency | EXIF, IPTC and XMP metadata are not written. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| heic | jpeg | — | supported | lossy | colorProfile, dimensions, metadata | Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| heic | heic | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| heic | heif | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| heic | webp | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| heic | avif | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| heic | tiff | — | supported | lossless | colorProfile, dimensions, metadata, transparency | MatrixTests.everyPath | |
| heic | bmp | — | supported | lossy | dimensions, transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| heic | gif | — | supported | lossy | dimensions, transparency | GIF stores at most 256 colours per frame and on/off transparency. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| heic | ico | — | supported | lossy | transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| heic | icns | — | supported | lossy | transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| heic | psd | — | supported | lossy | colorProfile, dimensions, transparency | EXIF, IPTC and XMP metadata are not written. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| heic | exr | — | supported | lossy | dimensions, transparency | Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| heic | hdr | — | supported | lossy | dimensions | HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| heic | tga | — | supported | lossy | dimensions, transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| heic | ppm | — | supported | lossy | dimensions | PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| heic | pgm | — | supported | lossy | dimensions | PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| heic | pbm | — | supported | lossy | dimensions | PBM has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| heic | jp2 | — | supported | lossy | dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| heif | png | — | supported | lossless | colorProfile, dimensions, metadata, transparency | MatrixTests.everyPath | |
| heif | apng | — | supported | lossless | colorProfile, dimensions, transparency | EXIF, IPTC and XMP metadata are not written. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| heif | jpeg | — | supported | lossy | colorProfile, dimensions, metadata | Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| heif | heic | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| heif | heif | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| heif | webp | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| heif | avif | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| heif | tiff | — | supported | lossless | colorProfile, dimensions, metadata, transparency | MatrixTests.everyPath | |
| heif | bmp | — | supported | lossy | dimensions, transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| heif | gif | — | supported | lossy | dimensions, transparency | GIF stores at most 256 colours per frame and on/off transparency. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| heif | ico | — | supported | lossy | transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| heif | icns | — | supported | lossy | transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| heif | psd | — | supported | lossy | colorProfile, dimensions, transparency | EXIF, IPTC and XMP metadata are not written. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| heif | exr | — | supported | lossy | dimensions, transparency | Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| heif | hdr | — | supported | lossy | dimensions | HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| heif | tga | — | supported | lossy | dimensions, transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| heif | ppm | — | supported | lossy | dimensions | PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| heif | pgm | — | supported | lossy | dimensions | PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| heif | pbm | — | supported | lossy | dimensions | PBM has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| heif | jp2 | — | supported | lossy | dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| webp | png | — | supported | lossless | colorProfile, dimensions, metadata, transparency | Animated sources: only the first frame is kept. | MatrixTests.everyPath |
| webp | apng | — | supported | lossless | animation, colorProfile, dimensions, transparency | EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| webp | jpeg | — | supported | lossy | colorProfile, dimensions, metadata | Animated sources: only the first frame is kept. Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Largest side: 65535 pixels. | MatrixTests.everyPath |
| webp | heic | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Animated sources: only the first frame is kept. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| webp | heif | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Animated sources: only the first frame is kept. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| webp | webp | — | supported | lossy | animation, colorProfile, dimensions, metadata, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Largest side: 16383 pixels. | MatrixTests.everyPath |
| webp | avif | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Animated sources: only the first frame is kept. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| webp | tiff | — | supported | lossless | colorProfile, dimensions, metadata, transparency | Animated sources: only the first frame is kept. | MatrixTests.everyPath |
| webp | bmp | — | supported | lossless | dimensions, transparency | Animated sources: only the first frame is kept. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| webp | gif | — | supported | lossy | animation, dimensions, transparency | GIF stores at most 256 colours per frame and on/off transparency. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| webp | ico | — | supported | lossy | transparency | Animated sources: only the first frame is kept. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| webp | icns | — | supported | lossy | transparency | Animated sources: only the first frame is kept. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| webp | psd | — | supported | lossy | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. EXIF, IPTC and XMP metadata are not written. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| webp | exr | — | supported | lossy | dimensions, transparency | Animated sources: only the first frame is kept. Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| webp | hdr | — | supported | lossy | dimensions | Animated sources: only the first frame is kept. HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| webp | tga | — | supported | lossless | dimensions, transparency | Animated sources: only the first frame is kept. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| webp | ppm | — | supported | lossy | dimensions | Animated sources: only the first frame is kept. PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| webp | pgm | — | supported | lossy | dimensions | Animated sources: only the first frame is kept. PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| webp | pbm | — | supported | lossy | dimensions | Animated sources: only the first frame is kept. PBM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| webp | jp2 | — | supported | lossy | dimensions, transparency | Animated sources: only the first frame is kept. Lossy by default (a lossless mode is available); the PSNR of the result is measured. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| avif | png | — | supported | lossless | colorProfile, dimensions, metadata, transparency | MatrixTests.everyPath | |
| avif | apng | — | supported | lossless | colorProfile, dimensions, transparency | EXIF, IPTC and XMP metadata are not written. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| avif | jpeg | — | supported | lossy | colorProfile, dimensions, metadata | Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| avif | heic | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| avif | heif | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| avif | webp | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| avif | avif | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| avif | tiff | — | supported | lossless | colorProfile, dimensions, metadata, transparency | MatrixTests.everyPath | |
| avif | bmp | — | supported | lossy | dimensions, transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| avif | gif | — | supported | lossy | dimensions, transparency | GIF stores at most 256 colours per frame and on/off transparency. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| avif | ico | — | supported | lossy | transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| avif | icns | — | supported | lossy | transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| avif | psd | — | supported | lossy | colorProfile, dimensions, transparency | EXIF, IPTC and XMP metadata are not written. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| avif | exr | — | supported | lossy | dimensions, transparency | Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| avif | hdr | — | supported | lossy | dimensions | HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| avif | tga | — | supported | lossy | dimensions, transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| avif | ppm | — | supported | lossy | dimensions | PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| avif | pgm | — | supported | lossy | dimensions | PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| avif | pbm | — | supported | lossy | dimensions | PBM has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| avif | jp2 | — | supported | lossy | dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| tiff | png | — | supported | lossless | colorProfile, dimensions, metadata, transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. | MatrixTests.everyPath |
| tiff | apng | — | supported | lossless | colorProfile, dimensions, transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. EXIF, IPTC and XMP metadata are not written. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| tiff | jpeg | — | supported | lossy | colorProfile, dimensions, metadata | Multi-page TIFF: a single page is converted (the first unless another is chosen). Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| tiff | heic | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Lossy compression; the PSNR of the result is measured. Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. At most 10 bits per component. | MatrixTests.everyPath |
| tiff | heif | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Lossy compression; the PSNR of the result is measured. Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| tiff | webp | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Lossy by default (a lossless mode is available); the PSNR of the result is measured. Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| tiff | avif | — | supported | lossy | colorProfile, dimensions, metadata, transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Lossy compression; the PSNR of the result is measured. Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. At most 10 bits per component. | MatrixTests.everyPath |
| tiff | tiff | — | supported | lossless | colorProfile, dimensions, hdr, metadata, transparency | MatrixTests.everyPath | |
| tiff | bmp | — | supported | lossy | dimensions, transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| tiff | gif | — | supported | lossy | dimensions, transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). GIF stores at most 256 colours per frame and on/off transparency. Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| tiff | ico | — | supported | lossy | transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| tiff | icns | — | supported | lossy | transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| tiff | psd | — | supported | lossy | colorProfile, dimensions, transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. EXIF, IPTC and XMP metadata are not written. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| tiff | exr | — | supported | lossy | dimensions, hdr, transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| tiff | hdr | — | supported | lossy | dimensions, hdr | Multi-page TIFF: a single page is converted (the first unless another is chosen). HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| tiff | tga | — | supported | lossy | dimensions, transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| tiff | ppm | — | supported | lossy | dimensions | Multi-page TIFF: a single page is converted (the first unless another is chosen). PPM has no transparency: transparent areas are filled with the background colour. Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| tiff | pgm | — | supported | lossy | dimensions | Multi-page TIFF: a single page is converted (the first unless another is chosen). PGM has no transparency: transparent areas are filled with the background colour. Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| tiff | pbm | — | supported | lossy | dimensions | Multi-page TIFF: a single page is converted (the first unless another is chosen). PBM has no transparency: transparent areas are filled with the background colour. Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| tiff | jp2 | — | supported | lossy | dimensions, transparency | Multi-page TIFF: a single page is converted (the first unless another is chosen). Lossy by default (a lossless mode is available); the PSNR of the result is measured. Floating-point (HDR) sources are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| bmp | png | — | supported | lossless | colorProfile, dimensions, transparency | MatrixTests.everyPath | |
| bmp | apng | — | supported | lossless | colorProfile, dimensions, transparency | A still source gives a single-frame PNG. | MatrixTests.everyPath |
| bmp | jpeg | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Largest side: 65535 pixels. | MatrixTests.everyPath |
| bmp | heic | — | supported | lossy | colorProfile, dimensions, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| bmp | heif | — | supported | lossy | colorProfile, dimensions, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| bmp | webp | — | supported | lossy | colorProfile, dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Largest side: 16383 pixels. | MatrixTests.everyPath |
| bmp | avif | — | supported | lossy | colorProfile, dimensions, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| bmp | tiff | — | supported | lossless | colorProfile, dimensions, transparency | MatrixTests.everyPath | |
| bmp | bmp | — | supported | lossless | dimensions, transparency | No embedded colour profile: pixels are converted to sRGB. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| bmp | gif | — | supported | lossy | dimensions, transparency | GIF stores at most 256 colours per frame and on/off transparency. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| bmp | ico | — | supported | lossy | transparency | No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| bmp | icns | — | supported | lossy | transparency | No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| bmp | psd | — | supported | lossy | colorProfile, dimensions, transparency | A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| bmp | exr | — | supported | lossy | dimensions, transparency | Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| bmp | hdr | — | supported | lossy | dimensions | HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| bmp | tga | — | supported | lossless | dimensions, transparency | No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| bmp | ppm | — | supported | lossy | dimensions | PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| bmp | pgm | — | supported | lossy | dimensions | PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| bmp | pbm | — | supported | lossy | dimensions | PBM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| bmp | jp2 | — | supported | lossy | dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| gif | png | — | supported | lossless | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. | MatrixTests.everyPath |
| gif | apng | — | supported | lossless | animation, colorProfile, dimensions, transparency | MatrixTests.everyPath | |
| gif | jpeg | — | supported | lossy | colorProfile, dimensions | Animated sources: only the first frame is kept. Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Largest side: 65535 pixels. | MatrixTests.everyPath |
| gif | heic | — | supported | lossy | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| gif | heif | — | supported | lossy | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| gif | webp | — | supported | lossy | animation, colorProfile, dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Largest side: 16383 pixels. | MatrixTests.everyPath |
| gif | avif | — | supported | lossy | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| gif | tiff | — | supported | lossless | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. | MatrixTests.everyPath |
| gif | bmp | — | supported | lossless | dimensions, transparency | Animated sources: only the first frame is kept. No embedded colour profile: pixels are converted to sRGB. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| gif | gif | — | supported | lossy | animation, dimensions, transparency | GIF stores at most 256 colours per frame and on/off transparency. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| gif | ico | — | supported | lossy | transparency | Animated sources: only the first frame is kept. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| gif | icns | — | supported | lossy | transparency | Animated sources: only the first frame is kept. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| gif | psd | — | supported | lossy | colorProfile, dimensions, transparency | Animated sources: only the first frame is kept. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| gif | exr | — | supported | lossy | dimensions, transparency | Animated sources: only the first frame is kept. Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| gif | hdr | — | supported | lossy | dimensions | Animated sources: only the first frame is kept. HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| gif | tga | — | supported | lossless | dimensions, transparency | Animated sources: only the first frame is kept. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| gif | ppm | — | supported | lossy | dimensions | Animated sources: only the first frame is kept. PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| gif | pgm | — | supported | lossy | dimensions | Animated sources: only the first frame is kept. PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| gif | pbm | — | supported | lossy | dimensions | Animated sources: only the first frame is kept. PBM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| gif | jp2 | — | supported | lossy | dimensions, transparency | Animated sources: only the first frame is kept. Lossy by default (a lossless mode is available); the PSNR of the result is measured. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| ico | png | — | supported | lossless | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. | MatrixTests.everyPath |
| ico | apng | — | supported | lossless | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| ico | jpeg | — | supported | lossy | colorProfile, dimensions | Only the largest representation of the icon is read. Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Largest side: 65535 pixels. | MatrixTests.everyPath |
| ico | heic | — | supported | lossy | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| ico | heif | — | supported | lossy | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| ico | webp | — | supported | lossy | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. Lossy by default (a lossless mode is available); the PSNR of the result is measured. Largest side: 16383 pixels. | MatrixTests.everyPath |
| ico | avif | — | supported | lossy | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| ico | tiff | — | supported | lossless | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. | MatrixTests.everyPath |
| ico | bmp | — | supported | lossless | dimensions, transparency | Only the largest representation of the icon is read. No embedded colour profile: pixels are converted to sRGB. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| ico | gif | — | supported | lossy | dimensions, transparency | Only the largest representation of the icon is read. GIF stores at most 256 colours per frame and on/off transparency. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| ico | ico | — | supported | lossy | transparency | Only the largest representation of the icon is read. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| ico | icns | — | supported | lossy | transparency | Only the largest representation of the icon is read. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| ico | psd | — | supported | lossy | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| ico | exr | — | supported | lossy | dimensions, transparency | Only the largest representation of the icon is read. Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| ico | hdr | — | supported | lossy | dimensions | Only the largest representation of the icon is read. HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| ico | tga | — | supported | lossless | dimensions, transparency | Only the largest representation of the icon is read. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| ico | ppm | — | supported | lossy | dimensions | Only the largest representation of the icon is read. PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| ico | pgm | — | supported | lossy | dimensions | Only the largest representation of the icon is read. PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| ico | pbm | — | supported | lossy | dimensions | Only the largest representation of the icon is read. PBM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| ico | jp2 | — | supported | lossy | dimensions, transparency | Only the largest representation of the icon is read. Lossy by default (a lossless mode is available); the PSNR of the result is measured. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| icns | png | — | supported | lossless | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. | MatrixTests.everyPath |
| icns | apng | — | supported | lossless | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| icns | jpeg | — | supported | lossy | colorProfile, dimensions | Only the largest representation of the icon is read. Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Largest side: 65535 pixels. | MatrixTests.everyPath |
| icns | heic | — | supported | lossy | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| icns | heif | — | supported | lossy | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| icns | webp | — | supported | lossy | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. Lossy by default (a lossless mode is available); the PSNR of the result is measured. Largest side: 16383 pixels. | MatrixTests.everyPath |
| icns | avif | — | supported | lossy | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| icns | tiff | — | supported | lossless | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. | MatrixTests.everyPath |
| icns | bmp | — | supported | lossless | dimensions, transparency | Only the largest representation of the icon is read. No embedded colour profile: pixels are converted to sRGB. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| icns | gif | — | supported | lossy | dimensions, transparency | Only the largest representation of the icon is read. GIF stores at most 256 colours per frame and on/off transparency. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| icns | ico | — | supported | lossy | transparency | Only the largest representation of the icon is read. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| icns | icns | — | supported | lossy | transparency | Only the largest representation of the icon is read. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| icns | psd | — | supported | lossy | colorProfile, dimensions, transparency | Only the largest representation of the icon is read. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| icns | exr | — | supported | lossy | dimensions, transparency | Only the largest representation of the icon is read. Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| icns | hdr | — | supported | lossy | dimensions | Only the largest representation of the icon is read. HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| icns | tga | — | supported | lossless | dimensions, transparency | Only the largest representation of the icon is read. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| icns | ppm | — | supported | lossy | dimensions | Only the largest representation of the icon is read. PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| icns | pgm | — | supported | lossy | dimensions | Only the largest representation of the icon is read. PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| icns | pbm | — | supported | lossy | dimensions | Only the largest representation of the icon is read. PBM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| icns | jp2 | — | supported | lossy | dimensions, transparency | Only the largest representation of the icon is read. Lossy by default (a lossless mode is available); the PSNR of the result is measured. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| psd | png | — | supported | lossless | colorProfile, dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. | MatrixTests.everyPath |
| psd | apng | — | supported | lossless | colorProfile, dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| psd | jpeg | — | supported | lossy | colorProfile, dimensions | Layers are not read: ImageIO returns the flattened composite stored in the file. Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| psd | heic | — | supported | lossy | colorProfile, dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| psd | heif | — | supported | lossy | colorProfile, dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| psd | webp | — | supported | lossy | colorProfile, dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| psd | avif | — | supported | lossy | colorProfile, dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| psd | tiff | — | supported | lossless | colorProfile, dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. | MatrixTests.everyPath |
| psd | bmp | — | supported | lossy | dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| psd | gif | — | supported | lossy | dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. GIF stores at most 256 colours per frame and on/off transparency. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| psd | ico | — | supported | lossy | transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| psd | icns | — | supported | lossy | transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| psd | psd | — | supported | lossy | colorProfile, dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| psd | exr | — | supported | lossy | dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| psd | hdr | — | supported | lossy | dimensions | Layers are not read: ImageIO returns the flattened composite stored in the file. HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| psd | tga | — | supported | lossy | dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| psd | ppm | — | supported | lossy | dimensions | Layers are not read: ImageIO returns the flattened composite stored in the file. PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| psd | pgm | — | supported | lossy | dimensions | Layers are not read: ImageIO returns the flattened composite stored in the file. PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| psd | pbm | — | supported | lossy | dimensions | Layers are not read: ImageIO returns the flattened composite stored in the file. PBM has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| psd | jp2 | — | supported | lossy | dimensions, transparency | Layers are not read: ImageIO returns the flattened composite stored in the file. Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| exr | png | — | supported | lossy | colorProfile, dimensions, transparency | HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. | MatrixTests.everyPath |
| exr | apng | — | supported | lossy | colorProfile, dimensions, transparency | HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| exr | jpeg | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| exr | heic | — | supported | lossy | colorProfile, dimensions, transparency | Lossy compression; the PSNR of the result is measured. HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. At most 10 bits per component. | MatrixTests.everyPath |
| exr | heif | — | supported | lossy | colorProfile, dimensions, transparency | Lossy compression; the PSNR of the result is measured. HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| exr | webp | — | supported | lossy | colorProfile, dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| exr | avif | — | supported | lossy | colorProfile, dimensions, transparency | Lossy compression; the PSNR of the result is measured. HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. At most 10 bits per component. | MatrixTests.everyPath |
| exr | tiff | — | supported | lossless | colorProfile, dimensions, hdr, transparency | MatrixTests.everyPath | |
| exr | bmp | — | supported | lossy | dimensions, transparency | HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| exr | gif | — | supported | lossy | dimensions, transparency | GIF stores at most 256 colours per frame and on/off transparency. HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| exr | ico | — | supported | lossy | transparency | HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| exr | icns | — | supported | lossy | transparency | HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| exr | psd | — | supported | lossy | colorProfile, dimensions, transparency | HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| exr | exr | — | supported | lossy | dimensions, hdr, transparency | Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| exr | hdr | — | supported | lossy | dimensions, hdr | HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| exr | tga | — | supported | lossy | dimensions, transparency | HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| exr | ppm | — | supported | lossy | dimensions | PPM has no transparency: transparent areas are filled with the background colour. HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| exr | pgm | — | supported | lossy | dimensions | PGM has no transparency: transparent areas are filled with the background colour. HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. No embedded colour profile: pixels are converted to sRGB. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| exr | pbm | — | supported | lossy | dimensions | PBM has no transparency: transparent areas are filled with the background colour. HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| exr | jp2 | — | supported | lossy | dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| hdr | png | — | supported | lossy | colorProfile, dimensions | HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. | MatrixTests.everyPath |
| hdr | apng | — | supported | lossy | colorProfile, dimensions | HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| hdr | jpeg | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| hdr | heic | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. At most 10 bits per component. | MatrixTests.everyPath |
| hdr | heif | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| hdr | webp | — | supported | lossy | colorProfile, dimensions | Lossy by default (a lossless mode is available); the PSNR of the result is measured. HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| hdr | avif | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. At most 10 bits per component. | MatrixTests.everyPath |
| hdr | tiff | — | supported | lossless | colorProfile, dimensions, hdr | MatrixTests.everyPath | |
| hdr | bmp | — | supported | lossy | dimensions | HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| hdr | gif | — | supported | lossy | dimensions | GIF stores at most 256 colours per frame and on/off transparency. HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| hdr | ico | — | supported | lossy | — | HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| hdr | icns | — | supported | lossy | — | HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| hdr | psd | — | supported | lossy | colorProfile, dimensions | HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| hdr | exr | — | supported | lossy | dimensions, hdr | Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| hdr | hdr | — | supported | lossy | dimensions, hdr | Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| hdr | tga | — | supported | lossy | dimensions | HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| hdr | ppm | — | supported | lossy | dimensions | HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| hdr | pgm | — | supported | lossy | dimensions | HDR values are tone-mapped into the SDR range. Samples deeper than 16-bit are reduced to 16-bit. No embedded colour profile: pixels are converted to sRGB. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| hdr | pbm | — | supported | lossy | dimensions | HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| hdr | jp2 | — | supported | lossy | dimensions | Lossy by default (a lossless mode is available); the PSNR of the result is measured. HDR values are tone-mapped into the SDR range. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| tga | png | — | supported | lossless | colorProfile, dimensions, transparency | MatrixTests.everyPath | |
| tga | apng | — | supported | lossless | colorProfile, dimensions, transparency | A still source gives a single-frame PNG. | MatrixTests.everyPath |
| tga | jpeg | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Largest side: 65535 pixels. | MatrixTests.everyPath |
| tga | heic | — | supported | lossy | colorProfile, dimensions, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| tga | heif | — | supported | lossy | colorProfile, dimensions, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| tga | webp | — | supported | lossy | colorProfile, dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Largest side: 16383 pixels. | MatrixTests.everyPath |
| tga | avif | — | supported | lossy | colorProfile, dimensions, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| tga | tiff | — | supported | lossless | colorProfile, dimensions, transparency | MatrixTests.everyPath | |
| tga | bmp | — | supported | lossless | dimensions, transparency | No embedded colour profile: pixels are converted to sRGB. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| tga | gif | — | supported | lossy | dimensions, transparency | GIF stores at most 256 colours per frame and on/off transparency. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| tga | ico | — | supported | lossy | transparency | No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| tga | icns | — | supported | lossy | transparency | No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| tga | psd | — | supported | lossy | colorProfile, dimensions, transparency | A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| tga | exr | — | supported | lossy | dimensions, transparency | Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| tga | hdr | — | supported | lossy | dimensions | HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| tga | tga | — | supported | lossless | dimensions, transparency | No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| tga | ppm | — | supported | lossy | dimensions | PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| tga | pgm | — | supported | lossy | dimensions | PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| tga | pbm | — | supported | lossy | dimensions | PBM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| tga | jp2 | — | supported | lossy | dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| ppm | png | — | supported | lossless | colorProfile, dimensions | MatrixTests.everyPath | |
| ppm | apng | — | supported | lossless | colorProfile, dimensions | A still source gives a single-frame PNG. | MatrixTests.everyPath |
| ppm | jpeg | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| ppm | heic | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| ppm | heif | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| ppm | webp | — | supported | lossy | colorProfile, dimensions | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| ppm | avif | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| ppm | tiff | — | supported | lossless | colorProfile, dimensions | MatrixTests.everyPath | |
| ppm | bmp | — | supported | lossy | dimensions | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| ppm | gif | — | supported | lossy | dimensions | GIF stores at most 256 colours per frame and on/off transparency. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| ppm | ico | — | supported | lossy | — | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| ppm | icns | — | supported | lossy | — | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| ppm | psd | — | supported | lossy | colorProfile, dimensions | A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| ppm | exr | — | supported | lossy | dimensions | Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| ppm | hdr | — | supported | lossy | dimensions | Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| ppm | tga | — | supported | lossy | dimensions | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| ppm | ppm | — | supported | lossless | dimensions | No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| ppm | pgm | — | supported | lossy | dimensions | No embedded colour profile: pixels are converted to sRGB. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| ppm | pbm | — | supported | lossy | dimensions | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| ppm | jp2 | — | supported | lossy | dimensions | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pgm | png | — | supported | lossless | colorProfile, dimensions | MatrixTests.everyPath | |
| pgm | apng | — | supported | lossless | colorProfile, dimensions | A still source gives a single-frame PNG. | MatrixTests.everyPath |
| pgm | jpeg | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| pgm | heic | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| pgm | heif | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| pgm | webp | — | supported | lossy | colorProfile, dimensions | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| pgm | avif | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| pgm | tiff | — | supported | lossless | colorProfile, dimensions | MatrixTests.everyPath | |
| pgm | bmp | — | supported | lossy | dimensions | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pgm | gif | — | supported | lossy | dimensions | GIF stores at most 256 colours per frame and on/off transparency. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pgm | ico | — | supported | lossy | — | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| pgm | icns | — | supported | lossy | — | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| pgm | psd | — | supported | lossy | colorProfile, dimensions | A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| pgm | exr | — | supported | lossy | dimensions | Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| pgm | hdr | — | supported | lossy | dimensions | Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| pgm | tga | — | supported | lossy | dimensions | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pgm | ppm | — | supported | lossless | dimensions | No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pgm | pgm | — | supported | lossless | dimensions | No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pgm | pbm | — | supported | lossy | dimensions | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| pgm | jp2 | — | supported | lossy | dimensions | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pbm | png | — | supported | lossless | colorProfile, dimensions | MatrixTests.everyPath | |
| pbm | apng | — | supported | lossless | colorProfile, dimensions | A still source gives a single-frame PNG. | MatrixTests.everyPath |
| pbm | jpeg | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. Largest side: 65535 pixels. | MatrixTests.everyPath |
| pbm | heic | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| pbm | heif | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| pbm | webp | — | supported | lossy | colorProfile, dimensions | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Largest side: 16383 pixels. | MatrixTests.everyPath |
| pbm | avif | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| pbm | tiff | — | supported | lossless | colorProfile, dimensions | MatrixTests.everyPath | |
| pbm | bmp | — | supported | lossless | dimensions | No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pbm | gif | — | supported | lossy | dimensions | GIF stores at most 256 colours per frame and on/off transparency. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pbm | ico | — | supported | lossy | — | No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| pbm | icns | — | supported | lossy | — | No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| pbm | psd | — | supported | lossy | colorProfile, dimensions | A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| pbm | exr | — | supported | lossy | dimensions | Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| pbm | hdr | — | supported | lossy | dimensions | Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| pbm | tga | — | supported | lossless | dimensions | No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pbm | ppm | — | supported | lossless | dimensions | No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pbm | pgm | — | supported | lossless | dimensions | No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pbm | pbm | — | supported | lossless | dimensions | No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| pbm | jp2 | — | supported | lossy | dimensions | Lossy by default (a lossless mode is available); the PSNR of the result is measured. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| jp2 | png | — | supported | lossless | colorProfile, dimensions, transparency | MatrixTests.everyPath | |
| jp2 | apng | — | supported | lossless | colorProfile, dimensions, transparency | A still source gives a single-frame PNG. | MatrixTests.everyPath |
| jp2 | jpeg | — | supported | lossy | colorProfile, dimensions | Lossy compression; the PSNR of the result is measured. JPEG has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| jp2 | heic | — | supported | lossy | colorProfile, dimensions, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| jp2 | heif | — | supported | lossy | colorProfile, dimensions, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| jp2 | webp | — | supported | lossy | colorProfile, dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| jp2 | avif | — | supported | lossy | colorProfile, dimensions, transparency | Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| jp2 | tiff | — | supported | lossless | colorProfile, dimensions, transparency | MatrixTests.everyPath | |
| jp2 | bmp | — | supported | lossy | dimensions, transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. Transparency is stored in a 32-bit BMP; some programs ignore BMP alpha. | MatrixTests.everyPath |
| jp2 | gif | — | supported | lossy | dimensions, transparency | GIF stores at most 256 colours per frame and on/off transparency. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| jp2 | ico | — | supported | lossy | transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| jp2 | icns | — | supported | lossy | transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| jp2 | psd | — | supported | lossy | colorProfile, dimensions, transparency | A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| jp2 | exr | — | supported | lossy | dimensions, transparency | Pixels are stored as linear values with sRGB / Rec. 709 primaries. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| jp2 | hdr | — | supported | lossy | dimensions | HDR has no transparency: transparent areas are filled with the background colour. Pixels are stored as linear values with sRGB / Rec. 709 primaries. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| jp2 | tga | — | supported | lossy | dimensions, transparency | Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| jp2 | ppm | — | supported | lossy | dimensions | PPM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| jp2 | pgm | — | supported | lossy | dimensions | PGM has no transparency: transparent areas are filled with the background colour. No embedded colour profile: pixels are converted to sRGB. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| jp2 | pbm | — | supported | lossy | dimensions | PBM has no transparency: transparent areas are filled with the background colour. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| jp2 | jp2 | — | supported | lossy | dimensions, transparency | Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. | MatrixTests.everyPath |
| dng | png | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. | MatrixTests.everyPath |
| dng | apng | — | experimental | lossy | colorProfile, dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. EXIF, IPTC and XMP metadata are not written. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| dng | jpeg | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Lossy compression; the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| dng | heic | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| dng | heif | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| dng | webp | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| dng | avif | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| dng | tiff | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. | MatrixTests.everyPath |
| dng | bmp | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| dng | gif | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. GIF stores at most 256 colours per frame and on/off transparency. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| dng | ico | — | experimental | lossy | — | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| dng | icns | — | experimental | lossy | — | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| dng | psd | — | experimental | lossy | colorProfile, dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. EXIF, IPTC and XMP metadata are not written. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| dng | exr | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| dng | hdr | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| dng | tga | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| dng | ppm | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| dng | pgm | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| dng | pbm | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| dng | jp2 | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. Tested only with a linear DNG generated in code; camera DNG files rely on the camera support of macOS. Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| raw | png | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. | MatrixTests.everyPath |
| raw | apng | — | experimental | lossy | colorProfile, dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. EXIF, IPTC and XMP metadata are not written. A still source gives a single-frame PNG. | MatrixTests.everyPath |
| raw | jpeg | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Lossy compression; the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 65535 pixels. | MatrixTests.everyPath |
| raw | heic | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| raw | heif | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. Written as an HEVC-coded HEIF file (the same encoding as HEIC). | MatrixTests.everyPath |
| raw | webp | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. Largest side: 16383 pixels. | MatrixTests.everyPath |
| raw | avif | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Lossy compression; the PSNR of the result is measured. At most 10 bits per component. | MatrixTests.everyPath |
| raw | tiff | — | experimental | lossy | colorProfile, dimensions, metadata | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. | MatrixTests.everyPath |
| raw | bmp | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| raw | gif | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. GIF stores at most 256 colours per frame and on/off transparency. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| raw | ico | — | experimental | lossy | — | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| raw | icns | — | experimental | lossy | — | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. The image is resampled to the standard icon sizes, fitted in a transparent square. | MatrixTests.everyPath |
| raw | psd | — | experimental | lossy | colorProfile, dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. EXIF, IPTC and XMP metadata are not written. A flat, single-layer PSD is written; partially transparent pixels are stored premultiplied. | MatrixTests.everyPath |
| raw | exr | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. 8-bit sources are stored as 16-bit half floats, deeper sources as 32-bit floats. | MatrixTests.everyPath |
| raw | hdr | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Pixels are stored as linear values with sRGB / Rec. 709 primaries. EXIF, IPTC and XMP metadata are not written. RGBE keeps an 8-bit mantissa per channel. | MatrixTests.everyPath |
| raw | tga | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| raw | ppm | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| raw | pgm | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Colour is reduced to gray (luma). | MatrixTests.everyPath |
| raw | pbm | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. Every pixel becomes black or white (50 % threshold). | MatrixTests.everyPath |
| raw | jp2 | — | experimental | lossy | dimensions | RAW development is Apple's default rendering (ImageIO): no exposure, white-balance or noise controls. No manufacturer RAW file was available to test on the build machine; decoding relies on the camera support of macOS. Lossy by default (a lossless mode is available); the PSNR of the result is measured. Samples deeper than 8-bit are reduced to 8-bit. No embedded colour profile: pixels are converted to sRGB. EXIF, IPTC and XMP metadata are not written. | MatrixTests.everyPath |
| png | png | image.optimize | supported | lossless | colorProfile, dimensions, metadata, transparency | Pixels are unchanged; only the compression is redone. | MatrixTests.operations |
| jpeg | jpeg | image.optimize | supported | lossy | colorProfile, dimensions, metadata | The image is decoded and encoded again: a new generation of JPEG loss is added. | MatrixTests.operations |
| webp | webp | image.optimize | supported | lossy | animation, colorProfile, dimensions, metadata, transparency | The image is decoded and encoded again; lossy unless “Lossless” is chosen. | MatrixTests.operations |