From 64e4fb3df67d34fb5b20244de411b192478ba7eb Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 09:37:15 +0000 Subject: [PATCH] feat(codecs): add managed JPEG decoder and pixel conversions Baseline, extended 12-bit, progressive and lossless (SOF3) Huffman decoding; 1/3/4 components with Adobe CMYK/YCCK; all integral sampling factors with libjpeg fancy upsampling; restart resynchronisation; DCT-domain scaling. Full-size blocks use a port of libjpeg's ISLOW IDCT, so output is bit-identical to djpeg on the cjpeg fixtures. PixelConvert maps interleaved 8/16-bit samples to linear ImageBuffers and back, gray/RGB, Exif orientation and clamping. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Core/Codecs/Jpeg/JpegDecoder.cs | 74 ++++ src/Titano.Core/Codecs/Jpeg/JpegHuffman.cs | 241 +++++++++++ src/Titano.Core/Codecs/Jpeg/JpegIdct.cs | 169 ++++++++ .../Codecs/Jpeg/JpegLosslessDecoder.cs | 136 ++++++ src/Titano.Core/Codecs/Jpeg/JpegParser.cs | 400 ++++++++++++++++++ src/Titano.Core/Codecs/Jpeg/JpegRenderer.cs | 378 +++++++++++++++++ .../Codecs/Jpeg/JpegScanDecoder.cs | 260 ++++++++++++ src/Titano.Core/Codecs/Jpeg/JpegTables.cs | 96 +++++ src/Titano.Core/Codecs/Jpeg/JpegTypes.cs | 153 +++++++ src/Titano.Core/Imaging/PixelConvert.cs | 390 +++++++++++++++++ .../Titano.Core.Tests/Codecs/CodecTestData.cs | 167 ++++++++ .../Codecs/JpegDecoderTests.cs | 79 ++++ tests/fixtures/codecs/jpeg/b411.jpg | Bin 0 -> 2169 bytes tests/fixtures/codecs/jpeg/b411.ppm | Bin 0 -> 8248 bytes tests/fixtures/codecs/jpeg/b420-nosmooth.ppm | Bin 0 -> 8248 bytes tests/fixtures/codecs/jpeg/b420.jpg | Bin 0 -> 2265 bytes tests/fixtures/codecs/jpeg/b420.ppm | Bin 0 -> 8248 bytes tests/fixtures/codecs/jpeg/b422.jpg | Bin 0 -> 2630 bytes tests/fixtures/codecs/jpeg/b422.ppm | Bin 0 -> 8248 bytes tests/fixtures/codecs/jpeg/b440.jpg | Bin 0 -> 2744 bytes tests/fixtures/codecs/jpeg/b440.ppm | Bin 0 -> 8248 bytes tests/fixtures/codecs/jpeg/b444.jpg | Bin 0 -> 3449 bytes tests/fixtures/codecs/jpeg/b444.ppm | Bin 0 -> 8248 bytes tests/fixtures/codecs/jpeg/cmyk.jpg | Bin 0 -> 5736 bytes tests/fixtures/codecs/jpeg/gray.jpg | Bin 0 -> 1562 bytes tests/fixtures/codecs/jpeg/gray.pgm | Bin 0 -> 2758 bytes tests/fixtures/codecs/jpeg/p420.jpg | Bin 0 -> 1992 bytes tests/fixtures/codecs/jpeg/p420.ppm | Bin 0 -> 8248 bytes tests/fixtures/codecs/jpeg/p444.jpg | Bin 0 -> 3651 bytes tests/fixtures/codecs/jpeg/p444.ppm | Bin 0 -> 8248 bytes tests/fixtures/codecs/jpeg/pgray.jpg | Bin 0 -> 1477 bytes tests/fixtures/codecs/jpeg/pgray.pgm | Bin 0 -> 2758 bytes tests/fixtures/codecs/jpeg/r420.jpg | Bin 0 -> 2395 bytes tests/fixtures/codecs/jpeg/r420.ppm | Bin 0 -> 8248 bytes tests/fixtures/codecs/jpeg/r444.jpg | Bin 0 -> 3236 bytes tests/fixtures/codecs/jpeg/r444.ppm | Bin 0 -> 8248 bytes tests/fixtures/codecs/make-fixtures.sh | 75 ++++ tests/fixtures/codecs/png/adam7-16.png | Bin 0 -> 5265 bytes tests/fixtures/codecs/png/adam7.png | Bin 0 -> 2780 bytes tests/fixtures/codecs/png/gray1.pam | Bin 0 -> 8296 bytes tests/fixtures/codecs/png/gray1.png | Bin 0 -> 241 bytes tests/fixtures/codecs/png/gray2.pam | Bin 0 -> 8296 bytes tests/fixtures/codecs/png/gray2.png | Bin 0 -> 308 bytes tests/fixtures/codecs/png/gray4.pam | Bin 0 -> 8296 bytes tests/fixtures/codecs/png/gray4.png | Bin 0 -> 685 bytes tests/fixtures/codecs/png/gray8.pam | Bin 0 -> 8296 bytes tests/fixtures/codecs/png/gray8.png | Bin 0 -> 1205 bytes tests/fixtures/codecs/png/graya.pam | Bin 0 -> 5563 bytes tests/fixtures/codecs/png/graya.png | Bin 0 -> 2152 bytes tests/fixtures/codecs/png/palette-adam7.pam | Bin 0 -> 8296 bytes tests/fixtures/codecs/png/palette-adam7.png | Bin 0 -> 920 bytes tests/fixtures/codecs/png/palette-trns.pam | Bin 0 -> 11047 bytes tests/fixtures/codecs/png/palette-trns.png | Bin 0 -> 727 bytes tests/fixtures/codecs/png/palette4.pam | Bin 0 -> 8296 bytes tests/fixtures/codecs/png/palette4.png | Bin 0 -> 691 bytes tests/fixtures/codecs/png/rgb16.png | Bin 0 -> 4841 bytes tests/fixtures/codecs/png/rgba.pam | Bin 0 -> 11047 bytes tests/fixtures/codecs/png/rgba.png | Bin 0 -> 3575 bytes tests/fixtures/codecs/src.ppm | Bin 0 -> 8248 bytes tests/fixtures/codecs/src16.ppm | Bin 0 -> 16485 bytes tests/fixtures/codecs/tiff/deflate16-pred.tif | Bin 0 -> 5288 bytes tests/fixtures/codecs/tiff/float32-pred3.tif | Bin 0 -> 8876 bytes .../fixtures/codecs/tiff/gray-miniswhite.tif | Bin 0 -> 2916 bytes tests/fixtures/codecs/tiff/jpeg-rgb.tif | Bin 0 -> 4768 bytes tests/fixtures/codecs/tiff/jpeg-ycbcr.tif | Bin 0 -> 2800 bytes tests/fixtures/codecs/tiff/lzw-pred.tif | Bin 0 -> 3670 bytes tests/fixtures/codecs/tiff/lzw-tiled.tif | Bin 0 -> 5064 bytes tests/fixtures/codecs/tiff/none-strips.tif | Bin 0 -> 8542 bytes tests/fixtures/codecs/tiff/packbits.tif | Bin 0 -> 7942 bytes tests/fixtures/codecs/tiff/planar-zip.tif | Bin 0 -> 2430 bytes 70 files changed, 2618 insertions(+) create mode 100644 src/Titano.Core/Codecs/Jpeg/JpegDecoder.cs create mode 100644 src/Titano.Core/Codecs/Jpeg/JpegHuffman.cs create mode 100644 src/Titano.Core/Codecs/Jpeg/JpegIdct.cs create mode 100644 src/Titano.Core/Codecs/Jpeg/JpegLosslessDecoder.cs create mode 100644 src/Titano.Core/Codecs/Jpeg/JpegParser.cs create mode 100644 src/Titano.Core/Codecs/Jpeg/JpegRenderer.cs create mode 100644 src/Titano.Core/Codecs/Jpeg/JpegScanDecoder.cs create mode 100644 src/Titano.Core/Codecs/Jpeg/JpegTables.cs create mode 100644 src/Titano.Core/Codecs/Jpeg/JpegTypes.cs create mode 100644 src/Titano.Core/Imaging/PixelConvert.cs create mode 100644 tests/Titano.Core.Tests/Codecs/CodecTestData.cs create mode 100644 tests/Titano.Core.Tests/Codecs/JpegDecoderTests.cs create mode 100644 tests/fixtures/codecs/jpeg/b411.jpg create mode 100644 tests/fixtures/codecs/jpeg/b411.ppm create mode 100644 tests/fixtures/codecs/jpeg/b420-nosmooth.ppm create mode 100644 tests/fixtures/codecs/jpeg/b420.jpg create mode 100644 tests/fixtures/codecs/jpeg/b420.ppm create mode 100644 tests/fixtures/codecs/jpeg/b422.jpg create mode 100644 tests/fixtures/codecs/jpeg/b422.ppm create mode 100644 tests/fixtures/codecs/jpeg/b440.jpg create mode 100644 tests/fixtures/codecs/jpeg/b440.ppm create mode 100644 tests/fixtures/codecs/jpeg/b444.jpg create mode 100644 tests/fixtures/codecs/jpeg/b444.ppm create mode 100644 tests/fixtures/codecs/jpeg/cmyk.jpg create mode 100644 tests/fixtures/codecs/jpeg/gray.jpg create mode 100644 tests/fixtures/codecs/jpeg/gray.pgm create mode 100644 tests/fixtures/codecs/jpeg/p420.jpg create mode 100644 tests/fixtures/codecs/jpeg/p420.ppm create mode 100644 tests/fixtures/codecs/jpeg/p444.jpg create mode 100644 tests/fixtures/codecs/jpeg/p444.ppm create mode 100644 tests/fixtures/codecs/jpeg/pgray.jpg create mode 100644 tests/fixtures/codecs/jpeg/pgray.pgm create mode 100644 tests/fixtures/codecs/jpeg/r420.jpg create mode 100644 tests/fixtures/codecs/jpeg/r420.ppm create mode 100644 tests/fixtures/codecs/jpeg/r444.jpg create mode 100644 tests/fixtures/codecs/jpeg/r444.ppm create mode 100755 tests/fixtures/codecs/make-fixtures.sh create mode 100644 tests/fixtures/codecs/png/adam7-16.png create mode 100644 tests/fixtures/codecs/png/adam7.png create mode 100644 tests/fixtures/codecs/png/gray1.pam create mode 100644 tests/fixtures/codecs/png/gray1.png create mode 100644 tests/fixtures/codecs/png/gray2.pam create mode 100644 tests/fixtures/codecs/png/gray2.png create mode 100644 tests/fixtures/codecs/png/gray4.pam create mode 100644 tests/fixtures/codecs/png/gray4.png create mode 100644 tests/fixtures/codecs/png/gray8.pam create mode 100644 tests/fixtures/codecs/png/gray8.png create mode 100644 tests/fixtures/codecs/png/graya.pam create mode 100644 tests/fixtures/codecs/png/graya.png create mode 100644 tests/fixtures/codecs/png/palette-adam7.pam create mode 100644 tests/fixtures/codecs/png/palette-adam7.png create mode 100644 tests/fixtures/codecs/png/palette-trns.pam create mode 100644 tests/fixtures/codecs/png/palette-trns.png create mode 100644 tests/fixtures/codecs/png/palette4.pam create mode 100644 tests/fixtures/codecs/png/palette4.png create mode 100644 tests/fixtures/codecs/png/rgb16.png create mode 100644 tests/fixtures/codecs/png/rgba.pam create mode 100644 tests/fixtures/codecs/png/rgba.png create mode 100644 tests/fixtures/codecs/src.ppm create mode 100644 tests/fixtures/codecs/src16.ppm create mode 100644 tests/fixtures/codecs/tiff/deflate16-pred.tif create mode 100644 tests/fixtures/codecs/tiff/float32-pred3.tif create mode 100644 tests/fixtures/codecs/tiff/gray-miniswhite.tif create mode 100644 tests/fixtures/codecs/tiff/jpeg-rgb.tif create mode 100644 tests/fixtures/codecs/tiff/jpeg-ycbcr.tif create mode 100644 tests/fixtures/codecs/tiff/lzw-pred.tif create mode 100644 tests/fixtures/codecs/tiff/lzw-tiled.tif create mode 100644 tests/fixtures/codecs/tiff/none-strips.tif create mode 100644 tests/fixtures/codecs/tiff/packbits.tif create mode 100644 tests/fixtures/codecs/tiff/planar-zip.tif diff --git a/src/Titano.Core/Codecs/Jpeg/JpegDecoder.cs b/src/Titano.Core/Codecs/Jpeg/JpegDecoder.cs new file mode 100644 index 00000000..00f32884 --- /dev/null +++ b/src/Titano.Core/Codecs/Jpeg/JpegDecoder.cs @@ -0,0 +1,74 @@ +using Titano.Core.Imaging; + +namespace Titano.Core.Codecs.Jpeg; + +/// +/// Managed JPEG decoder: baseline, extended (12-bit), progressive and lossless Huffman streams; 1, 3 or 4 components +/// (CMYK/YCCK via Adobe APP14); any integral sampling factors; restart intervals with resynchronisation on corrupt +/// data; DCT-domain scaling for thumbnails. Exif orientation is not applied. Malformed headers throw +/// ; damaged entropy-coded data yields a partial image plus warnings. +/// +public static class JpegDecoder +{ + private static readonly float[]?[] LinearLuts = new float[17][]; + + /// Reads the frame header only (no pixel decoding). + public static JpegInfo ReadInfo(ReadOnlySpan data) + { + var parser = new JpegParser(JpegDecodeOptions.Default); + parser.Parse(data, headerOnly: true); + return parser.Info(); + } + + /// Decodes to interleaved gray or RGB samples (8-bit, or 16-bit containers for higher precisions). + public static JpegImage Decode(ReadOnlySpan data, JpegDecodeOptions? options = null) + { + var parser = Parse(data, options); + if (parser.Frame!.Process == JpegProcess.Lossless) return LosslessToImage(parser); + return new JpegRenderer(parser).RenderInterleaved(parser.Info()); + } + + /// Decodes into a linear-light (samples are taken as sRGB-encoded). + /// Return gray images as three identical channels instead of one. + public static ImageBuffer DecodeToLinear(ReadOnlySpan data, JpegDecodeOptions? options = null, bool expandGray = false) + { + var parser = Parse(data, options); + if (parser.Frame!.Process == JpegProcess.Lossless) + { + var image = LosslessToImage(parser); + var channels = image.Components == 1 && expandGray ? 3 : image.Components; + return image.Pixels8 is { } p8 + ? PixelConvert.FromInterleaved8(p8, image.Width, image.Height, image.Components, outputChannels: channels) + : PixelConvert.FromInterleaved16(image.Pixels16, image.Width, image.Height, image.Components, maxValue: (1 << image.BitDepth) - 1, outputChannels: channels); + } + return new JpegRenderer(parser).RenderLinear(expandGray); + } + + private static JpegParser Parse(ReadOnlySpan data, JpegDecodeOptions? options) + { + var parser = new JpegParser(options ?? JpegDecodeOptions.Default); + parser.Parse(data); + return parser; + } + + private static JpegImage LosslessToImage(JpegParser parser) + { + var raw = JpegLosslessDecoder.Finish(parser); + if (raw.Components is not (1 or 3)) throw new InvalidDataException($"JPEG: {raw.Components}-component lossless images have no colour interpretation"); + if (raw.Precision > 8) + return new JpegImage(parser.Info(), raw.Width, raw.Height, raw.Components, raw.Precision, null, raw.Samples, [.. parser.Warnings]); + var bytes = new byte[raw.Samples.Length]; + for (var i = 0; i < bytes.Length; i++) bytes[i] = (byte)raw.Samples[i]; + return new JpegImage(parser.Info(), raw.Width, raw.Height, raw.Components, 8, bytes, null, [.. parser.Warnings]); + } + + /// sRGB-decoding table for codes 0..2^precision−1. + internal static float[] LinearLut(int precision) + { + if (LinearLuts[precision] is { } cached) return cached; + var size = 1 << precision; + var lut = new float[size]; + for (var i = 0; i < size; i++) lut[i] = (float)ColorSpace.SrgbToLinear(i / (double)(size - 1)); + return LinearLuts[precision] = lut; + } +} diff --git a/src/Titano.Core/Codecs/Jpeg/JpegHuffman.cs b/src/Titano.Core/Codecs/Jpeg/JpegHuffman.cs new file mode 100644 index 00000000..5a41440f --- /dev/null +++ b/src/Titano.Core/Codecs/Jpeg/JpegHuffman.cs @@ -0,0 +1,241 @@ +using System.Runtime.CompilerServices; + +namespace Titano.Core.Codecs.Jpeg; + +/// Canonical Huffman decoding table with a 9-bit lookahead (and a combined run/value table for AC). +internal sealed class JpegHuffmanTable +{ + public const int FastBits = 9; + + /// (length << 8) | symbol for codes of ≤ bits; 0 = longer code. + public readonly ushort[] Fast = new ushort[1 << FastBits]; + + /// Exclusive upper bound of each code length's codes, left-aligned to 16 bits. + public readonly int[] MaxCode = new int[18]; + + /// Symbol index = (code >> (16 − length)) + Delta[length]. + public readonly int[] Delta = new int[17]; + + public readonly byte[] Values = new byte[256]; + + /// For AC tables: (value << 16) | (run << 8) | totalBits when code and magnitude fit in the lookahead. + public readonly int[] FastAc = new int[1 << FastBits]; + + /// Builds a table from the 16 code-length counts and the symbols (DHT layout). + /// The lengths oversubscribe the code space. + public JpegHuffmanTable(ReadOnlySpan counts, ReadOnlySpan values) + { + int code = 0, k = 0; + for (var len = 1; len <= 16; len++) + { + Delta[len] = k - code; + for (var i = 0; i < counts[len - 1]; i++, code++, k++) + { + if (len > FastBits) continue; + var first = code << (FastBits - len); + Fast.AsSpan(first, 1 << (FastBits - len)).Fill((ushort)(len << 8 | values[k])); + } + if (code > 1 << len) throw new InvalidDataException("JPEG: Huffman table oversubscribed"); + MaxCode[len] = code << (16 - len); + code <<= 1; + } + MaxCode[17] = int.MaxValue; + values[..k].CopyTo(Values); + BuildFastAc(); + } + + private void BuildFastAc() + { + for (var i = 0; i < Fast.Length; i++) + { + int e = Fast[i]; + if (e == 0) continue; + var len = e >> 8; + var rs = e & 0xFF; + int run = rs >> 4, s = rs & 15; + if (s == 0 || len + s > FastBits) continue; + var m = (i >> (FastBits - len - s)) & ((1 << s) - 1); + var v = m < 1 << (s - 1) ? m - (1 << s) + 1 : m; + FastAc[i] = v << 16 | run << 8 | (len + s); + } + } +} + +/// Thrown inside a scan when entropy-coded data is corrupt; the scan decoder resynchronises. +internal sealed class JpegEntropyException(string message) : Exception(message); + +/// +/// MSB-first bit reader over entropy-coded JPEG data: removes 0xFF00 stuffing, stops at markers and then +/// feeds zero bits, counting them so that consumption past the real data is detectable (). +/// +internal ref struct JpegBitReader +{ + private readonly ReadOnlySpan _data; + private int _pos; + private ulong _bits; + private int _count; + private int _padBits; + private int _marker; + private int _markerPos; + + public JpegBitReader(ReadOnlySpan data, int start) + { + _data = data; + _pos = start; + } + + /// Marker code that stopped the reader (0 = none, -1 = end of data). + public readonly int Marker => _marker; + + /// True once bits beyond the entropy-coded segment have been consumed. + public readonly bool Overrun => _padBits > _count; + + /// Where marker parsing continues after the scan. + public readonly int Position => _marker > 0 ? _markerPos : _pos; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Ensure(int n) + { + if (_count < n) Fill(); + } + + /// Next bits (1..32) without consuming; call first. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public readonly int Peek(int n) => (int)(_bits >> (64 - n)); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Consume(int n) + { + _bits <<= n; + _count -= n; + } + + /// Reads 1..16 bits. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int ReadBits(int n) + { + if (_count < n) Fill(); + var v = (int)(_bits >> (64 - n)); + _bits <<= n; + _count -= n; + return v; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int ReadBit() + { + if (_count < 1) Fill(); + var v = (int)(_bits >> 63); + _bits <<= 1; + _count--; + return v; + } + + /// Reads an -bit magnitude (1..16) and sign-extends it (T.81 F.2.2.1 EXTEND). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int Receive(int s) + { + var v = ReadBits(s); + return v + ((((v >> (s - 1)) & 1) - 1) & (1 - (1 << s))); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int Decode(JpegHuffmanTable t) + { + if (_count < 16) Fill(); + int e = t.Fast[(int)(_bits >> (64 - JpegHuffmanTable.FastBits))]; + if (e != 0) + { + var len = e >> 8; + _bits <<= len; + _count -= len; + return e & 0xFF; + } + return DecodeSlow(t); + } + + private int DecodeSlow(JpegHuffmanTable t) + { + var code = (int)(_bits >> 48); + for (var len = JpegHuffmanTable.FastBits + 1; len <= 16; len++) + { + if (code < t.MaxCode[len]) + { + Consume(len); + return t.Values[(code >> (16 - len)) + t.Delta[len]]; + } + } + throw new JpegEntropyException("JPEG: invalid Huffman code"); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public void Fill() + { + while (_count <= 56) + { + if (_marker != 0 || _pos >= _data.Length) + { + if (_marker == 0) _marker = -1; + _padBits += 8; + _count += 8; + continue; + } + int b = _data[_pos]; + if (b == 0xFF) + { + var p = _pos + 1; + while (p < _data.Length && _data[p] == 0xFF) p++; + if (p >= _data.Length) + { + _pos = p; + continue; + } + if (_data[p] != 0) + { + _marker = _data[p]; + _markerPos = p - 1; + continue; + } + _pos = p + 1; + } + else + { + _pos++; + } + _bits |= (ulong)(uint)b << (56 - _count); + _count += 8; + } + } + + /// Discards buffered bits and locates the next marker (for restart processing). Returns its code + /// (-1 when the data ends) without consuming it; steps over it. + public int FindMarker() + { + _bits = 0; + _count = 0; + _padBits = 0; + if (_marker > 0) return _marker; + var p = _pos; + while (p + 1 < _data.Length) + { + if (_data[p] == 0xFF && _data[p + 1] is not (0x00 or 0xFF)) + { + _marker = _data[p + 1]; + _markerPos = p; + return _marker; + } + p++; + } + _pos = _data.Length; + _marker = -1; + return -1; + } + + /// Consumes the marker found by and resumes reading after it. + public void AcceptMarker() + { + if (_marker <= 0) return; + _pos = _markerPos + 2; + _marker = 0; + } +} diff --git a/src/Titano.Core/Codecs/Jpeg/JpegIdct.cs b/src/Titano.Core/Codecs/Jpeg/JpegIdct.cs new file mode 100644 index 00000000..41c8c826 --- /dev/null +++ b/src/Titano.Core/Codecs/Jpeg/JpegIdct.cs @@ -0,0 +1,169 @@ +namespace Titano.Core.Codecs.Jpeg; + +/// +/// Inverse DCT. Full-size blocks use libjpeg's accurate integer algorithm (jidctint ISLOW: Loeffler–Ligtenberg– +/// Moschytz with 13-bit constants), so output is bit-identical to libjpeg/djpeg. Reduced sizes (4, 2, 1) evaluate +/// the low-frequency n×n coefficients on an n-point grid in float (DCT-domain scaling for thumbnails). +/// +internal static class JpegIdct +{ + private const int ConstBits = 13; + private const int Fix0298631336 = 2446, Fix0390180644 = 3196, Fix0541196100 = 4433, Fix0765366865 = 6270; + private const int Fix0899976223 = 7373, Fix1175875602 = 9633, Fix1501321110 = 12299, Fix1847759065 = 15137; + private const int Fix1961570560 = 16069, Fix2053119869 = 16819, Fix2562915447 = 20995, Fix3072711026 = 25172; + + private static readonly float[] Basis4 = JpegTables.BuildBasis(4); + private static readonly float[] Basis2 = JpegTables.BuildBasis(2); + + /// Transforms one block into n·n samples, level-shifted and clamped to 0..2^precision−1. + /// 64 quantised coefficients, natural order. + /// 64 dequantisation factors, natural order. + /// Output block size: 8, 4, 2 or 1. + /// Sample precision (8 or 12). + public static void Transform(ReadOnlySpan coefficients, ReadOnlySpan quant, int size, int precision, Span output) + { + var max = (1 << precision) - 1; + var center = 1 << (precision - 1); + if (size == 8) + { + Islow(coefficients, quant, precision == 8 ? 2 : 1, center, max, output); + return; + } + if (size == 1) + { + output[0] = Math.Clamp((int)MathF.Round(coefficients[0] * quant[0] * 0.125f) + center, 0, max); + return; + } + Reduced(coefficients, quant, size, size == 4 ? Basis4 : Basis2, center, max, output); + } + + /// Port of libjpeg-turbo jpeg_idct_islow (columns, then rows; PASS1_BITS 2 for 8-bit, 1 for 12-bit). + private static void Islow(ReadOnlySpan c, ReadOnlySpan q, int pass1Bits, int center, int max, Span output) + { + Span ws = stackalloc int[64]; + _ = c[63]; + _ = q[63]; + for (var col = 0; col < 8; col++) + { + if (c[8 + col] == 0 && c[16 + col] == 0 && c[24 + col] == 0 && c[32 + col] == 0 && + c[40 + col] == 0 && c[48 + col] == 0 && c[56 + col] == 0) + { + var dc = c[col] * q[col] << pass1Bits; + for (var r = 0; r < 8; r++) ws[r * 8 + col] = dc; + continue; + } + var shift = ConstBits - pass1Bits; + Butterfly( + c[col] * q[col], c[8 + col] * q[8 + col], c[16 + col] * q[16 + col], c[24 + col] * q[24 + col], + c[32 + col] * q[32 + col], c[40 + col] * q[40 + col], c[48 + col] * q[48 + col], c[56 + col] * q[56 + col], + out var o0, out var o1, out var o2, out var o3, out var o4, out var o5, out var o6, out var o7); + var round = 1 << (shift - 1); + ws[col] = (o0 + round) >> shift; + ws[8 + col] = (o1 + round) >> shift; + ws[16 + col] = (o2 + round) >> shift; + ws[24 + col] = (o3 + round) >> shift; + ws[32 + col] = (o4 + round) >> shift; + ws[40 + col] = (o5 + round) >> shift; + ws[48 + col] = (o6 + round) >> shift; + ws[56 + col] = (o7 + round) >> shift; + } + for (var row = 0; row < 8; row++) + { + var w = ws.Slice(row * 8, 8); + var o = output.Slice(row * 8, 8); + if (w[1] == 0 && w[2] == 0 && w[3] == 0 && w[4] == 0 && w[5] == 0 && w[6] == 0 && w[7] == 0) + { + var dcShift = pass1Bits + 3; + o.Fill(Math.Clamp(((w[0] + (1 << (dcShift - 1))) >> dcShift) + center, 0, max)); + continue; + } + var shift = ConstBits + pass1Bits + 3; + var round = 1 << (shift - 1); + Butterfly(w[0], w[1], w[2], w[3], w[4], w[5], w[6], w[7], + out var o0, out var o1, out var o2, out var o3, out var o4, out var o5, out var o6, out var o7); + o[0] = Math.Clamp(((o0 + round) >> shift) + center, 0, max); + o[1] = Math.Clamp(((o1 + round) >> shift) + center, 0, max); + o[2] = Math.Clamp(((o2 + round) >> shift) + center, 0, max); + o[3] = Math.Clamp(((o3 + round) >> shift) + center, 0, max); + o[4] = Math.Clamp(((o4 + round) >> shift) + center, 0, max); + o[5] = Math.Clamp(((o5 + round) >> shift) + center, 0, max); + o[6] = Math.Clamp(((o6 + round) >> shift) + center, 0, max); + o[7] = Math.Clamp(((o7 + round) >> shift) + center, 0, max); + } + } + + /// One 8-point ISLOW pass; outputs are scaled by 2^13 (CONST_BITS) before descaling. + private static void Butterfly(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, + out int o0, out int o1, out int o2, out int o3, out int o4, out int o5, out int o6, out int o7) + { + // Even part: the rotator is sqrt(2)·c(−6). + var z1 = (i2 + i6) * Fix0541196100; + var tmp2 = z1 - i6 * Fix1847759065; + var tmp3 = z1 + i2 * Fix0765366865; + var tmp0 = (i0 + i4) << ConstBits; + var tmp1 = (i0 - i4) << ConstBits; + int tmp10 = tmp0 + tmp3, tmp13 = tmp0 - tmp3, tmp11 = tmp1 + tmp2, tmp12 = tmp1 - tmp2; + + // Odd part (figure 8 of the LL&M paper). + tmp0 = i7; + tmp1 = i5; + tmp2 = i3; + tmp3 = i1; + z1 = tmp0 + tmp3; + var z2 = tmp1 + tmp2; + var z3 = tmp0 + tmp2; + var z4 = tmp1 + tmp3; + var z5 = (z3 + z4) * Fix1175875602; + tmp0 *= Fix0298631336; + tmp1 *= Fix2053119869; + tmp2 *= Fix3072711026; + tmp3 *= Fix1501321110; + z1 *= -Fix0899976223; + z2 *= -Fix2562915447; + z3 = z3 * -Fix1961570560 + z5; + z4 = z4 * -Fix0390180644 + z5; + tmp0 += z1 + z3; + tmp1 += z2 + z4; + tmp2 += z2 + z3; + tmp3 += z1 + z4; + + o0 = tmp10 + tmp3; + o7 = tmp10 - tmp3; + o1 = tmp11 + tmp2; + o6 = tmp11 - tmp2; + o2 = tmp12 + tmp1; + o5 = tmp12 - tmp1; + o3 = tmp13 + tmp0; + o4 = tmp13 - tmp0; + } + + /// n-point IDCT of the low-frequency n×n coefficients, evaluated at the centres of n output samples. + private static void Reduced(ReadOnlySpan coefficients, ReadOnlySpan quant, int n, float[] basis, int center, int max, Span output) + { + Span g = stackalloc float[n * n]; + Span f = stackalloc float[n]; + g.Clear(); + for (var v = 0; v < n; v++) + { + var row = g.Slice(v * n, n); + for (var u = 0; u < n; u++) + { + int coef = coefficients[v * 8 + u]; + if (coef == 0) continue; + var value = (float)(coef * quant[v * 8 + u]); + for (var x = 0; x < n; x++) row[x] += value * basis[u * n + x]; + } + } + for (var y = 0; y < n; y++) + { + f.Clear(); + for (var v = 0; v < n; v++) + { + var w = basis[v * n + y]; + var row = g.Slice(v * n, n); + for (var x = 0; x < n; x++) f[x] += w * row[x]; + } + for (var x = 0; x < n; x++) output[y * n + x] = Math.Clamp((int)MathF.Round(f[x]) + center, 0, max); + } + } +} diff --git a/src/Titano.Core/Codecs/Jpeg/JpegLosslessDecoder.cs b/src/Titano.Core/Codecs/Jpeg/JpegLosslessDecoder.cs new file mode 100644 index 00000000..3ae36db9 --- /dev/null +++ b/src/Titano.Core/Codecs/Jpeg/JpegLosslessDecoder.cs @@ -0,0 +1,136 @@ +namespace Titano.Core.Codecs.Jpeg; + +/// +/// Lossless JPEG (SOF3, ITU T.81 Annex H) as used by DNG raw tiles and CR2: predictors 1–7, point transform, +/// 2–16 bit precision, one or more components (interleaved or in separate scans), restart intervals. +/// +public static class JpegLosslessDecoder +{ + /// Decodes a lossless stream to interleaved samples with the frame's own width and component count + /// (DNG tiles often encode e.g. two components at half the tile width; callers re-map the sample order). + /// The stream is malformed or not lossless. + public static JpegLosslessImage Decode(ReadOnlySpan data) + { + var parser = new JpegParser(JpegDecodeOptions.Default); + parser.Parse(data); + if (parser.Frame!.Process != JpegProcess.Lossless) throw new InvalidDataException("JPEG: not a lossless (SOF3) stream"); + return Finish(parser); + } + + /// Applies each component's point transform and packages the samples. + internal static JpegLosslessImage Finish(JpegParser parser) + { + var f = parser.Frame!; + var n = f.Components.Length; + var samples = parser.LosslessSamples ?? new ushort[checked(f.Width * f.Height * n)]; + foreach (var c in f.Components) + { + if (c.PointTransform == 0) continue; + for (var i = c.Index; i < samples.Length; i += n) samples[i] = (ushort)(samples[i] << c.PointTransform); + c.PointTransform = 0; + } + parser.LosslessSamples = samples; + return new JpegLosslessImage(samples, f.Width, f.Height, n, f.Precision); + } + + internal static int DecodeScan(JpegParser parser, ReadOnlySpan data, int pos, JpegScan scan) + { + var f = parser.Frame!; + int width = f.Width, nf = f.Components.Length, stride = width * nf; + var samples = parser.LosslessSamples ??= new ushort[checked(stride * f.Height)]; + var comps = scan.Components; + var tables = scan.DcTables; + var ns = comps.Length; + var index = new int[ns]; + for (var i = 0; i < ns; i++) + { + index[i] = comps[i].Index; + comps[i].PointTransform = scan.Al; + } + var predictor = scan.Ss; + var initial = 1 << (f.Precision - scan.Al - 1); + var interval = parser.RestartInterval; + var total = (long)width * f.Height; + var reader = new JpegBitReader(data, pos); + + long mcu = 0; + int x = 0, y = 0, restartRow = 0, expectedRst = 0; + var first = true; + while (mcu < total) + { + var end = interval > 0 ? Math.Min(total, mcu + interval) : total; + try + { + for (; mcu < end; mcu++) + { + var at = y * stride + x * nf; + for (var i = 0; i < ns; i++) + { + var s = reader.Decode(tables[i]!); + var diff = s switch + { + 0 => 0, + 16 => 32768, + > 16 => throw new JpegEntropyException("JPEG: bad lossless difference magnitude"), + _ => reader.Receive(s), + }; + var idx = at + index[i]; + int pred; + if (first) pred = initial; + else if (y == restartRow) pred = samples[idx - nf]; + else if (x == 0) pred = samples[idx - stride]; + else pred = Predict(predictor, samples[idx - nf], samples[idx - stride], samples[idx - stride - nf]); + samples[idx] = (ushort)(pred + diff); + } + first = false; + if (++x == width) + { + x = 0; + y++; + if (reader.Overrun) throw new JpegEntropyException("JPEG: premature end of entropy-coded data"); + } + } + if (reader.Overrun) throw new JpegEntropyException("JPEG: premature end of entropy-coded data"); + } + catch (JpegEntropyException ex) + { + parser.Warn(ex.Message); + if (interval == 0) break; + mcu = end; + } + if (mcu >= total || interval == 0) break; + + var marker = reader.FindMarker(); + if (marker is < JpegTables.Rst0 or > JpegTables.Rst0 + 7) + { + parser.Warn("JPEG: restart marker missing; scan truncated"); + break; + } + var found = marker - JpegTables.Rst0; + if (found != expectedRst) + { + var lost = (found - expectedRst) & 7; + parser.Warn($"JPEG: {lost} restart interval(s) lost"); + mcu += (long)lost * interval; + } + reader.AcceptMarker(); + expectedRst = (found + 1) & 7; + x = (int)(mcu % width); + y = (int)(mcu / width); + restartRow = y; + first = true; + } + return reader.Position; + } + + private static int Predict(int predictor, int ra, int rb, int rc) => predictor switch + { + 1 => ra, + 2 => rb, + 3 => rc, + 4 => ra + rb - rc, + 5 => ra + ((rb - rc) >> 1), + 6 => rb + ((ra - rc) >> 1), + _ => (ra + rb) >> 1, + }; +} diff --git a/src/Titano.Core/Codecs/Jpeg/JpegParser.cs b/src/Titano.Core/Codecs/Jpeg/JpegParser.cs new file mode 100644 index 00000000..ec660afd --- /dev/null +++ b/src/Titano.Core/Codecs/Jpeg/JpegParser.cs @@ -0,0 +1,400 @@ +namespace Titano.Core.Codecs.Jpeg; + +/// One frame component and its coefficient (DCT) storage. +internal sealed class JpegComponent +{ + public int Id, Index, H, V, QuantTable; + + /// Component size in samples: ceil(X·H/Hmax) × ceil(Y·V/Vmax). + public int Width, Height; + + /// Blocks covering the component (non-interleaved scan extent). + public int WidthInBlocks, HeightInBlocks; + + /// Allocated block grid, padded to whole MCUs. + public int BlocksPerLine, BlocksPerColumn; + + /// Quantised coefficients, 64 per block in natural order, blocks row-major. + public short[]? Coefficients; + + /// Quantisation table latched when the component's first scan starts (natural order). + public ushort[]? Quant; + + /// Point transform of the lossless scan that carried this component. + public int PointTransform; + + public int DcPred; +} + +/// Frame header (SOFn) with derived MCU geometry. +internal sealed class JpegFrame +{ + public required JpegProcess Process { get; init; } + public required int Precision { get; init; } + public required int Width { get; init; } + public required int Height { get; init; } + public required JpegComponent[] Components { get; init; } + public int HMax { get; init; } + public int VMax { get; init; } + public int McusX { get; init; } + public int McusY { get; init; } +} + +/// Scan header (SOS) resolved against the frame. +internal sealed class JpegScan +{ + public required JpegComponent[] Components { get; init; } + public required JpegHuffmanTable?[] DcTables { get; init; } + public required JpegHuffmanTable?[] AcTables { get; init; } + public int Ss { get; init; } + public int Se { get; init; } + public int Ah { get; init; } + public int Al { get; init; } +} + +/// +/// Marker-level JPEG parser: tables, frame and scan headers; dispatches entropy-coded segments to the DCT or +/// lossless scan decoders. Structural errors throw ; once a scan has been +/// decoded, later errors only end parsing with a warning so that partial images survive. +/// +internal sealed class JpegParser(JpegDecodeOptions options) +{ + private readonly ushort[]?[] _quant = new ushort[4][]; + private readonly JpegHuffmanTable?[] _dc = new JpegHuffmanTable[4]; + private readonly JpegHuffmanTable?[] _ac = new JpegHuffmanTable[4]; + private readonly List _warnings = []; + private static JpegHuffmanTable? _stdDcLuma, _stdDcChroma, _stdAcLuma, _stdAcChroma; + + public JpegDecodeOptions Options { get; } = options; + public JpegFrame? Frame { get; private set; } + public int RestartInterval { get; private set; } + public int AdobeTransform { get; private set; } = -1; + public bool Jfif { get; private set; } + public int ScansDecoded { get; private set; } + public IReadOnlyList Warnings => _warnings; + + /// Interleaved samples of a lossless frame (point transform not yet applied). + public ushort[]? LosslessSamples { get; set; } + + public void Warn(string message) + { + if (_warnings.Count < 64) _warnings.Add(message); + } + + /// Parses a full stream. With it stops at the first scan header. + public void Parse(ReadOnlySpan data, bool headerOnly = false) + { + if (Options.Tables is { Length: > 0 } tables) ParseCore(tables, tablesOnly: true, headerOnly: false); + try + { + ParseCore(data, tablesOnly: false, headerOnly); + } + catch (InvalidDataException ex) when (ScansDecoded > 0) + { + Warn(ex.Message); + } + if (Frame is null) throw new InvalidDataException("JPEG: no frame header"); + if (!headerOnly && ScansDecoded == 0) throw new InvalidDataException("JPEG: no scan data"); + } + + public JpegInfo Info() + { + var f = Frame ?? throw new InvalidDataException("JPEG: no frame header"); + return new JpegInfo( + f.Width, f.Height, f.Components.Length, f.Precision, f.Process, ColorSpace(), + f.Components.Select(c => (c.H, c.V)).ToArray(), RestartInterval); + } + + /// Colour space after applying the option override and libjpeg's marker/component-id heuristics. + public JpegColorSpace ColorSpace() + { + var f = Frame!; + var n = f.Components.Length; + if (n == 1) return JpegColorSpace.Gray; + if (f.Process == JpegProcess.Lossless && Options.ColorTransform == JpegColorTransform.Auto) + return n switch { 3 => JpegColorSpace.Rgb, 4 => JpegColorSpace.Cmyk, _ => JpegColorSpace.Other }; + var transformed = Options.ColorTransform switch + { + JpegColorTransform.None => false, + JpegColorTransform.YCbCr => true, + _ => n == 3 + ? Jfif || (AdobeTransform < 0 ? !(f.Components[0].Id == 'R' && f.Components[1].Id == 'G' && f.Components[2].Id == 'B') : AdobeTransform != 0) + : AdobeTransform == 2, + }; + return n switch + { + 3 => transformed ? JpegColorSpace.YCbCr : JpegColorSpace.Rgb, + 4 => transformed ? JpegColorSpace.Ycck : JpegColorSpace.Cmyk, + _ => JpegColorSpace.Other, + }; + } + + private void ParseCore(ReadOnlySpan data, bool tablesOnly, bool headerOnly) + { + if (data.Length < 4 || data[0] != 0xFF || data[1] != JpegTables.Soi) throw new InvalidDataException("JPEG: missing SOI marker"); + var pos = 2; + while (true) + { + var marker = NextMarker(data, ref pos); + if (marker < 0) + { + if (!tablesOnly) Warn("JPEG: missing EOI marker"); + return; + } + if (marker == JpegTables.Eoi) return; + if (marker is JpegTables.Soi or (>= JpegTables.Rst0 and <= JpegTables.Rst0 + 7) or 0x01) continue; + if (pos + 2 > data.Length) throw new InvalidDataException("JPEG: truncated marker segment"); + var length = data[pos] << 8 | data[pos + 1]; + if (length < 2 || pos + length > data.Length) throw new InvalidDataException($"JPEG: bad length for marker 0x{marker:X2}"); + var segment = data.Slice(pos + 2, length - 2); + pos += length; + switch (marker) + { + case JpegTables.Dqt: + ParseDqt(segment); + break; + case JpegTables.Dht: + ParseDht(segment); + break; + case JpegTables.Dri: + if (segment.Length < 2) throw new InvalidDataException("JPEG: bad DRI"); + RestartInterval = segment[0] << 8 | segment[1]; + break; + case JpegTables.App0: + if (segment.StartsWith("JFIF\0"u8)) Jfif = true; + break; + case JpegTables.App14: + if (segment.Length >= 12 && segment.StartsWith("Adobe"u8)) AdobeTransform = segment[11]; + break; + case >= JpegTables.Sof0 and <= JpegTables.Sof3: + if (tablesOnly) throw new InvalidDataException("JPEG: frame header in a tables-only stream"); + if (Frame is not null) throw new InvalidDataException("JPEG: more than one frame"); + ParseSof(marker, segment); + break; + case JpegTables.Sos: + if (tablesOnly || Frame is null) throw new InvalidDataException("JPEG: scan without frame header"); + if (headerOnly) return; + pos = DecodeScan(data, segment, pos); + ScansDecoded++; + break; + case JpegTables.Dac: + throw new InvalidDataException("JPEG: arithmetic coding is not supported"); + case >= 0xC5 and <= 0xCF: + throw new InvalidDataException($"JPEG: unsupported coding process (SOF 0x{marker:X2})"); + } + } + } + + /// Finds the next marker at or after , skipping garbage; returns its code or -1. + private int NextMarker(ReadOnlySpan data, ref int pos) + { + var start = pos; + while (pos + 1 < data.Length) + { + if (data[pos] != 0xFF) + { + pos++; + continue; + } + int m = data[pos + 1]; + if (m == 0xFF) + { + pos++; + continue; + } + if (m == 0) + { + pos += 2; + continue; + } + if (pos != start) Warn($"JPEG: {pos - start} extraneous bytes before marker 0x{m:X2}"); + pos += 2; + return m; + } + pos = data.Length; + return -1; + } + + private void ParseDqt(ReadOnlySpan s) + { + while (s.Length > 0) + { + int pq = s[0] >> 4, tq = s[0] & 15; + var size = pq == 0 ? 64 : 128; + if (pq > 1 || tq > 3 || s.Length < 1 + size) throw new InvalidDataException("JPEG: bad DQT"); + var table = new ushort[64]; + for (var k = 0; k < 64; k++) + { + table[JpegTables.NaturalOrder[k]] = pq == 0 ? s[1 + k] : (ushort)(s[1 + 2 * k] << 8 | s[2 + 2 * k]); + } + _quant[tq] = table; + s = s[(1 + size)..]; + } + } + + private void ParseDht(ReadOnlySpan s) + { + while (s.Length > 0) + { + if (s.Length < 17) throw new InvalidDataException("JPEG: bad DHT"); + int tc = s[0] >> 4, th = s[0] & 15; + if (tc > 1 || th > 3) throw new InvalidDataException("JPEG: bad DHT class/id"); + var counts = s.Slice(1, 16); + var total = 0; + foreach (var c in counts) total += c; + if (total > 256 || s.Length < 17 + total) throw new InvalidDataException("JPEG: bad DHT counts"); + var table = new JpegHuffmanTable(counts, s.Slice(17, total)); + (tc == 0 ? _dc : _ac)[th] = table; + s = s[(17 + total)..]; + } + } + + private void ParseSof(int marker, ReadOnlySpan s) + { + if (s.Length < 6) throw new InvalidDataException("JPEG: bad SOF"); + var process = marker switch + { + JpegTables.Sof0 => JpegProcess.Baseline, + JpegTables.Sof1 => JpegProcess.ExtendedSequential, + JpegTables.Sof2 => JpegProcess.Progressive, + _ => JpegProcess.Lossless, + }; + int precision = s[0], height = s[1] << 8 | s[2], width = s[3] << 8 | s[4], n = s[5]; + if (process == JpegProcess.Lossless ? precision is < 2 or > 16 : precision is not (8 or 12)) + throw new InvalidDataException($"JPEG: unsupported precision {precision}"); + if (width == 0 || height == 0) throw new InvalidDataException("JPEG: zero image size (DNL is not supported)"); + if ((long)width * height > Options.MaxPixels) throw new InvalidDataException($"JPEG: {width}x{height} exceeds the pixel limit"); + if (n is < 1 or > 4 || s.Length < 6 + 3 * n) throw new InvalidDataException("JPEG: bad component count"); + var components = new JpegComponent[n]; + int hMax = 1, vMax = 1; + for (var i = 0; i < n; i++) + { + var c = s.Slice(6 + 3 * i, 3); + int h = c[1] >> 4, v = c[1] & 15; + if (h is < 1 or > 4 || v is < 1 or > 4 || c[2] > 3) throw new InvalidDataException("JPEG: bad sampling factors"); + components[i] = new JpegComponent { Id = c[0], Index = i, H = h, V = v, QuantTable = c[2] }; + hMax = Math.Max(hMax, h); + vMax = Math.Max(vMax, v); + } + if (n == 1) + { + // A single component is always coded non-interleaved: its own factors are irrelevant. + components[0].H = components[0].V = hMax = vMax = 1; + } + foreach (var c in components) + { + if (hMax % c.H != 0 || vMax % c.V != 0) throw new InvalidDataException("JPEG: fractional sampling ratios are not supported"); + if (process == JpegProcess.Lossless && (c.H != 1 || c.V != 1)) + throw new InvalidDataException("JPEG: subsampled lossless streams are not supported"); + } + var unit = process == JpegProcess.Lossless ? 1 : 8; + var mcusX = DivUp(width, unit * hMax); + var mcusY = DivUp(height, unit * vMax); + foreach (var c in components) + { + c.Width = DivUp(width * c.H, hMax); + c.Height = DivUp(height * c.V, vMax); + c.WidthInBlocks = DivUp(c.Width, 8); + c.HeightInBlocks = DivUp(c.Height, 8); + c.BlocksPerLine = mcusX * c.H; + c.BlocksPerColumn = mcusY * c.V; + } + Frame = new JpegFrame + { + Process = process, Precision = precision, Width = width, Height = height, Components = components, + HMax = hMax, VMax = vMax, McusX = mcusX, McusY = mcusY, + }; + } + + private int DecodeScan(ReadOnlySpan data, ReadOnlySpan s, int pos) + { + var frame = Frame!; + if (s.Length < 1) throw new InvalidDataException("JPEG: bad SOS"); + int n = s[0]; + if (n is < 1 or > 4 || s.Length < 4 + 2 * n) throw new InvalidDataException("JPEG: bad SOS component count"); + var comps = new JpegComponent[n]; + var dc = new JpegHuffmanTable?[n]; + var ac = new JpegHuffmanTable?[n]; + var tdTa = new int[n]; + for (var i = 0; i < n; i++) + { + int id = s[1 + 2 * i]; + JpegComponent? match = null; + foreach (var c in frame.Components) + { + if (c.Id == id && Array.IndexOf(comps, c) < 0) + { + match = c; + break; + } + } + comps[i] = match ?? throw new InvalidDataException($"JPEG: scan references unknown component {id}"); + tdTa[i] = s[2 + 2 * i]; + } + var p = 1 + 2 * n; + int ss = s[p], se = s[p + 1], ah = s[p + 2] >> 4, al = s[p + 2] & 15; + + if (frame.Process == JpegProcess.Lossless) + { + if (ss is < 1 or > 7) throw new InvalidDataException($"JPEG: bad lossless predictor {ss}"); + if (al >= frame.Precision) throw new InvalidDataException("JPEG: bad point transform"); + for (var i = 0; i < n; i++) dc[i] = _dc[tdTa[i] >> 4 & 3] ?? throw new InvalidDataException("JPEG: missing Huffman table"); + var losslessScan = new JpegScan { Components = comps, DcTables = dc, AcTables = ac, Ss = ss, Al = al }; + return JpegLosslessDecoder.DecodeScan(this, data, pos, losslessScan); + } + + var progressive = frame.Process == JpegProcess.Progressive; + if (progressive) + { + if (ss > se || se > 63 || (ss == 0 && se != 0) || (ss > 0 && n != 1) || al > 13 || ah > 13) + throw new InvalidDataException("JPEG: bad progressive scan parameters"); + } + else + { + ss = 0; + se = 63; + ah = al = 0; + } + if (n > 1) + { + var blocks = 0; + foreach (var c in comps) blocks += c.H * c.V; + if (blocks > 10) throw new InvalidDataException("JPEG: too many blocks per MCU"); + } + var needDc = ss == 0 && ah == 0; + var needAc = se > 0; + for (var i = 0; i < n; i++) + { + int td = tdTa[i] >> 4, ta = tdTa[i] & 15; + if (td > 3 || ta > 3) throw new InvalidDataException("JPEG: bad Huffman table selector"); + if (needDc) dc[i] = _dc[td] ?? StandardTable(dc: true, td); + if (needAc) ac[i] = _ac[ta] ?? StandardTable(dc: false, ta); + var c = comps[i]; + if (c.Quant is null) + { + c.Quant = _quant[c.QuantTable] is { } q ? (ushort[])q.Clone() : throw new InvalidDataException("JPEG: missing quantisation table"); + } + c.Coefficients ??= new short[checked(c.BlocksPerLine * c.BlocksPerColumn * 64)]; + } + var scan = new JpegScan { Components = comps, DcTables = dc, AcTables = ac, Ss = ss, Se = se, Ah = ah, Al = al }; + return JpegScanDecoder.Decode(this, data, pos, scan); + } + + /// Quantisation table for a component that never appeared in a scan (rendered flat). + public ushort[] QuantFor(JpegComponent c) => c.Quant ?? _quant[c.QuantTable] ?? new ushort[64]; + + /// Annex K tables for streams that omit DHT (Motion-JPEG), as libjpeg does. + private static JpegHuffmanTable StandardTable(bool dc, int id) + { + if (id > 1) throw new InvalidDataException("JPEG: missing Huffman table"); + return (dc, id) switch + { + (true, 0) => _stdDcLuma ??= new JpegHuffmanTable(JpegTables.DcLumaBits, JpegTables.DcLumaValues), + (true, _) => _stdDcChroma ??= new JpegHuffmanTable(JpegTables.DcChromaBits, JpegTables.DcChromaValues), + (false, 0) => _stdAcLuma ??= new JpegHuffmanTable(JpegTables.AcLumaBits, JpegTables.AcLumaValues), + _ => _stdAcChroma ??= new JpegHuffmanTable(JpegTables.AcChromaBits, JpegTables.AcChromaValues), + }; + } + + internal static int DivUp(int a, int b) => (int)(((long)a + b - 1) / b); +} diff --git a/src/Titano.Core/Codecs/Jpeg/JpegRenderer.cs b/src/Titano.Core/Codecs/Jpeg/JpegRenderer.cs new file mode 100644 index 00000000..1140772f --- /dev/null +++ b/src/Titano.Core/Codecs/Jpeg/JpegRenderer.cs @@ -0,0 +1,378 @@ +using System.Buffers; +using System.Numerics; +using Titano.Core.Imaging; + +namespace Titano.Core.Codecs.Jpeg; + +/// +/// Turns decoded coefficients into pixels: (A) parallel IDCT of every block into per-component sample planes, +/// (B) parallel bands of rows doing chroma upsampling (libjpeg "fancy" triangle filters for 2× factors, +/// replication otherwise) and colour conversion (libjpeg's fixed-point YCbCr tables, CMYK/YCCK → RGB). +/// +internal sealed class JpegRenderer +{ + private const int BandRows = 16; + + private readonly JpegParser _parser; + private readonly JpegFrame _frame; + private readonly int _n; + private readonly bool _fancy; + private readonly int _max; + private readonly JpegColorSpace _colorSpace; + private readonly bool _invertedCmyk; + private readonly ParallelOptions _parallel; + private readonly byte[]?[] _planes8; + private readonly ushort[]?[] _planes16; + private readonly int[] _stride, _validW, _validH, _hf, _vf; + + public JpegRenderer(JpegParser parser) + { + _parser = parser; + _frame = parser.Frame!; + var options = parser.Options; + _n = BlockSize(_frame, options.MaxLongEdge); + _fancy = options.FancyUpsampling && _n > 1; + _max = (1 << _frame.Precision) - 1; + _colorSpace = parser.ColorSpace(); + _invertedCmyk = parser.AdobeTransform >= 0 || _colorSpace == JpegColorSpace.Ycck; + _parallel = new ParallelOptions { MaxDegreeOfParallelism = options.MaxDegreeOfParallelism }; + Width = JpegParser.DivUp(_frame.Width * _n, 8); + Height = JpegParser.DivUp(_frame.Height * _n, 8); + Channels = _colorSpace == JpegColorSpace.Gray ? 1 : 3; + if (_colorSpace == JpegColorSpace.Other) throw new InvalidDataException("JPEG: component count has no colour interpretation"); + + var count = _frame.Components.Length; + _planes8 = new byte[count][]; + _planes16 = new ushort[count][]; + _stride = new int[count]; + _validW = new int[count]; + _validH = new int[count]; + _hf = new int[count]; + _vf = new int[count]; + for (var i = 0; i < count; i++) + { + var c = _frame.Components[i]; + _hf[i] = _frame.HMax / c.H; + _vf[i] = _frame.VMax / c.V; + _validW[i] = JpegParser.DivUp(_frame.Width * c.H * _n, _frame.HMax * 8); + _validH[i] = JpegParser.DivUp(_frame.Height * c.V * _n, _frame.VMax * 8); + } + } + + public int Width { get; } + public int Height { get; } + + /// Output channels: 1 for gray, 3 otherwise. + public int Channels { get; } + + /// IDCT output size per block (8 = full size, 4/2/1 = DCT-domain scaling) for a requested long edge. + public static int BlockSize(JpegFrame frame, int maxLongEdge) + { + if (maxLongEdge <= 0) return 8; + var longEdge = Math.Max(frame.Width, frame.Height); + foreach (var n in (ReadOnlySpan)[1, 2, 4]) + { + if (JpegParser.DivUp(longEdge * n, 8) >= maxLongEdge) return n; + } + return 8; + } + + public JpegImage RenderInterleaved(JpegInfo info) + { + RunIdct(); + var length = checked(Width * Height * Channels); + if (_frame.Precision <= 8) + { + var pixels = new byte[length]; + Render((y, rows) => + { + var dst = pixels.AsSpan(y * Width * Channels, Width * Channels); + for (var c = 0; c < Channels; c++) + { + var src = rows[c]; + for (var x = 0; x < Width; x++) dst[x * Channels + c] = (byte)src[x]; + } + }); + return new JpegImage(info, Width, Height, Channels, 8, pixels, null, [.. _parser.Warnings]); + } + var pixels16 = new ushort[length]; + Render((y, rows) => + { + var dst = pixels16.AsSpan(y * Width * Channels, Width * Channels); + for (var c = 0; c < Channels; c++) + { + var src = rows[c]; + for (var x = 0; x < Width; x++) dst[x * Channels + c] = (ushort)src[x]; + } + }); + return new JpegImage(info, Width, Height, Channels, _frame.Precision, null, pixels16, [.. _parser.Warnings]); + } + + /// Renders straight into linear-light float planes (sRGB transfer removed by table lookup). + public ImageBuffer RenderLinear(bool expandGray) + { + RunIdct(); + var lut = _frame.Precision == 8 ? null : JpegDecoder.LinearLut(_frame.Precision); + var outChannels = Channels == 1 && !expandGray ? 1 : 3; + var image = new ImageBuffer(Width, Height, outChannels, clear: false); + var storage = image.Storage; + var plane = image.PlaneLength; + Render((y, rows) => + { + for (var c = 0; c < outChannels; c++) + { + var src = rows[Channels == 1 ? 0 : c]; + var dst = storage.AsSpan(c * plane + y * Width, Width); + if (lut is null) + { + for (var x = 0; x < dst.Length; x++) dst[x] = ColorSpace.Linear8((byte)src[x]); + } + else + { + for (var x = 0; x < dst.Length; x++) dst[x] = lut[src[x]]; + } + } + }); + return image; + } + + private void RunIdct() + { + var comps = _frame.Components; + var center = 1 << (_frame.Precision - 1); + var jobs = new List<(int Component, int BlockRow)>(); + for (var i = 0; i < comps.Length; i++) + { + var c = comps[i]; + _stride[i] = c.BlocksPerLine * _n; + var length = checked(_stride[i] * c.BlocksPerColumn * _n); + if (_frame.Precision <= 8) _planes8[i] = new byte[length]; + else _planes16[i] = new ushort[length]; + var blockRows = JpegParser.DivUp(_validH[i], _n); + for (var by = 0; by < blockRows; by++) jobs.Add((i, by)); + } + var quant = new int[comps.Length][]; + for (var i = 0; i < comps.Length; i++) quant[i] = Array.ConvertAll(_parser.QuantFor(comps[i]), q => (int)q); + + Parallel.For(0, jobs.Count, _parallel, () => new int[64], (j, _, block) => + { + var (i, by) = jobs[j]; + var c = comps[i]; + var stride = _stride[i]; + var rowOffset = by * _n * stride; + if (c.Coefficients is not { } coefficients) + { + // Component never scanned: flat mid-grey, like zero coefficients. + if (_planes8[i] is { } flat8) flat8.AsSpan(rowOffset, _n * stride).Fill((byte)center); + else _planes16[i].AsSpan(rowOffset, _n * stride).Fill((ushort)center); + return block; + } + var blocks = JpegParser.DivUp(_validW[i], _n); + for (var bx = 0; bx < blocks; bx++) + { + JpegIdct.Transform(coefficients.AsSpan((by * c.BlocksPerLine + bx) * 64, 64), quant[i], _n, _frame.Precision, block); + var at = rowOffset + bx * _n; + for (var y = 0; y < _n; y++, at += stride) + { + var src = block.AsSpan(y * _n, _n); + if (_planes8[i] is { } p8) + { + var dst = p8.AsSpan(at, _n); + for (var x = 0; x < _n; x++) dst[x] = (byte)src[x]; + } + else + { + var dst = _planes16[i].AsSpan(at, _n); + for (var x = 0; x < _n; x++) dst[x] = (ushort)src[x]; + } + } + } + return block; + }, _ => { }); + foreach (var c in comps) c.Coefficients = null; + } + + private delegate void RowSink(int y, int[][] rows); + + private void Render(RowSink sink) + { + var bands = JpegParser.DivUp(Height, BandRows); + var count = _frame.Components.Length; + var ycc = _colorSpace is JpegColorSpace.YCbCr or JpegColorSpace.Ycck ? YccTables.For(_frame.Precision) : null; + Parallel.For(0, bands, _parallel, band => + { + var rows = new int[count][]; + for (var c = 0; c < count; c++) rows[c] = ArrayPool.Shared.Rent(Width + 1); + try + { + var end = Math.Min(Height, (band + 1) * BandRows); + for (var y = band * BandRows; y < end; y++) + { + for (var c = 0; c < count; c++) + { + if (_planes8[c] is { } p8) Upsample(p8, c, y, rows[c]); + else Upsample(_planes16[c]!, c, y, rows[c]); + } + ConvertColor(rows, ycc); + sink(y, rows); + } + } + finally + { + foreach (var r in rows) ArrayPool.Shared.Return(r); + } + }); + } + + /// Writes one output row of component at full output width. + /// holds at least Width + 1 values, enough for the 2·w samples a 2× upsampler produces. + private void Upsample(T[] plane, int c, int y, int[] dst) where T : unmanaged, IBinaryInteger + { + int hf = _hf[c], vf = _vf[c], stride = _stride[c], w = _validW[c], h = _validH[c]; + var cy = Math.Min(y / vf, h - 1); + var near = plane.AsSpan(cy * stride, w); + var width = Width; + if (hf == 1 && vf == 1) + { + for (var x = 0; x < width; x++) dst[x] = int.CreateTruncating(near[x]); + return; + } + if (_fancy && vf == 2 && hf <= 2) + { + var upper = (y & 1) == 0; + var far = plane.AsSpan(Math.Clamp(upper ? cy - 1 : cy + 1, 0, h - 1) * stride, w); + if (hf == 1) + { + var bias = upper ? 1 : 2; + for (var x = 0; x < width; x++) dst[x] = (3 * int.CreateTruncating(near[x]) + int.CreateTruncating(far[x]) + bias) >> 2; + return; + } + if (w > 2) + { + H2V2(near, far, w, dst); + return; + } + } + if (_fancy && hf == 2 && vf == 1 && w > 2) + { + H2V1(near, w, dst); + return; + } + for (var x = 0; x < width; x++) dst[x] = int.CreateTruncating(near[x / hf]); + } + + /// libjpeg h2v1_fancy_upsample: 3/4·nearer + 1/4·further, alternating rounding bias. + private static void H2V1(ReadOnlySpan s, int w, Span o) where T : unmanaged, IBinaryInteger + { + var first = int.CreateTruncating(s[0]); + o[0] = first; + o[1] = (3 * first + int.CreateTruncating(s[1]) + 2) >> 2; + for (var i = 1; i < w - 1; i++) + { + var v = 3 * int.CreateTruncating(s[i]); + o[2 * i] = (v + int.CreateTruncating(s[i - 1]) + 1) >> 2; + o[2 * i + 1] = (v + int.CreateTruncating(s[i + 1]) + 2) >> 2; + } + var last = int.CreateTruncating(s[w - 1]); + o[2 * w - 2] = (3 * last + int.CreateTruncating(s[w - 2]) + 1) >> 2; + o[2 * w - 1] = last; + } + + /// libjpeg h2v2_fancy_upsample: triangle filter in both directions (9/3/3/1 weights). + private static void H2V2(ReadOnlySpan near, ReadOnlySpan far, int w, Span o) where T : unmanaged, IBinaryInteger + { + var thisSum = 3 * int.CreateTruncating(near[0]) + int.CreateTruncating(far[0]); + var nextSum = 3 * int.CreateTruncating(near[1]) + int.CreateTruncating(far[1]); + o[0] = (thisSum * 4 + 8) >> 4; + o[1] = (thisSum * 3 + nextSum + 7) >> 4; + var lastSum = thisSum; + thisSum = nextSum; + for (var i = 1; i < w - 1; i++) + { + nextSum = 3 * int.CreateTruncating(near[i + 1]) + int.CreateTruncating(far[i + 1]); + o[2 * i] = (thisSum * 3 + lastSum + 8) >> 4; + o[2 * i + 1] = (thisSum * 3 + nextSum + 7) >> 4; + lastSum = thisSum; + thisSum = nextSum; + } + o[2 * w - 2] = (thisSum * 3 + lastSum + 8) >> 4; + o[2 * w - 1] = (thisSum * 4 + 7) >> 4; + } + + private void ConvertColor(int[][] rows, YccTables? ycc) + { + var w = Width; + var max = _max; + switch (_colorSpace) + { + case JpegColorSpace.YCbCr: + YccToRgb(rows, ycc!, w, max); + break; + case JpegColorSpace.Cmyk or JpegColorSpace.Ycck: + { + if (_colorSpace == JpegColorSpace.Ycck) + { + YccToRgb(rows, ycc!, w, max); + for (var c = 0; c < 3; c++) + { + var r = rows[c]; + for (var x = 0; x < w; x++) r[x] = max - r[x]; + } + } + var k = rows[3]; + var half = max / 2; + for (var c = 0; c < 3; c++) + { + var r = rows[c]; + for (var x = 0; x < w; x++) + { + r[x] = _invertedCmyk ? (r[x] * k[x] + half) / max : ((max - r[x]) * (max - k[x]) + half) / max; + } + } + break; + } + } + } + + private static void YccToRgb(int[][] rows, YccTables t, int w, int max) + { + int[] y = rows[0], cb = rows[1], cr = rows[2]; + for (var x = 0; x < w; x++) + { + int yy = y[x], b = cb[x], r = cr[x]; + y[x] = Math.Clamp(yy + t.CrR[r], 0, max); + cb[x] = Math.Clamp(yy + ((t.CbG[b] + t.CrG[r]) >> 16), 0, max); + cr[x] = Math.Clamp(yy + t.CbB[b], 0, max); + } + } + + /// libjpeg's fixed-point (16 fractional bits) YCbCr → RGB tables for a sample precision. + private sealed class YccTables + { + private static readonly YccTables?[] Cache = new YccTables?[17]; + public readonly int[] CrR, CbB, CrG, CbG; + + private YccTables(int precision) + { + var size = 1 << precision; + var center = size / 2; + CrR = new int[size]; + CbB = new int[size]; + CrG = new int[size]; + CbG = new int[size]; + const int half = 1 << 15; + for (var i = 0; i < size; i++) + { + var x = i - center; + CrR[i] = (Fix(1.40200) * x + half) >> 16; + CbB[i] = (Fix(1.77200) * x + half) >> 16; + CrG[i] = -Fix(0.71414) * x; + CbG[i] = -Fix(0.34414) * x + half; + } + } + + public static YccTables For(int precision) => Cache[precision] ??= new YccTables(precision); + + private static int Fix(double v) => (int)(v * 65536 + 0.5); + } +} diff --git a/src/Titano.Core/Codecs/Jpeg/JpegScanDecoder.cs b/src/Titano.Core/Codecs/Jpeg/JpegScanDecoder.cs new file mode 100644 index 00000000..9e90a42b --- /dev/null +++ b/src/Titano.Core/Codecs/Jpeg/JpegScanDecoder.cs @@ -0,0 +1,260 @@ +namespace Titano.Core.Codecs.Jpeg; + +/// +/// Entropy decoding of DCT scans into the components' coefficient arrays: sequential (baseline/extended) and the +/// four progressive scan kinds (DC first/refine, AC first/refine). Corrupt intervals are skipped by resynchronising +/// on the next RSTn marker; without restart markers the rest of the scan is abandoned with a warning. +/// +internal static class JpegScanDecoder +{ + private enum Kind + { + Sequential, + DcFirst, + DcRefine, + AcFirst, + AcRefine, + } + + public static int Decode(JpegParser parser, ReadOnlySpan data, int pos, JpegScan scan) + { + var frame = parser.Frame!; + var comps = scan.Components; + var kind = frame.Process != JpegProcess.Progressive ? Kind.Sequential + : scan.Ss == 0 ? (scan.Ah == 0 ? Kind.DcFirst : Kind.DcRefine) + : (scan.Ah == 0 ? Kind.AcFirst : Kind.AcRefine); + + var single = comps.Length == 1; + var mcusX = single ? comps[0].WidthInBlocks : frame.McusX; + var mcusY = single ? comps[0].HeightInBlocks : frame.McusY; + var total = (long)mcusX * mcusY; + var interval = parser.RestartInterval; + var reader = new JpegBitReader(data, pos); + var state = new ScanState(scan); + var expectedRst = 0; + foreach (var c in comps) c.DcPred = 0; + + long mcu = 0; + while (mcu < total) + { + var end = interval > 0 ? Math.Min(total, mcu + interval) : total; + try + { + for (; mcu < end; mcu++) + { + if (single) + { + var c = comps[0]; + var bx = (int)(mcu % mcusX); + var by = (int)(mcu / mcusX); + DecodeBlock(ref reader, kind, c, (by * c.BlocksPerLine + bx) * 64, 0, ref state); + } + else + { + var mx = (int)(mcu % mcusX); + var my = (int)(mcu / mcusX); + for (var i = 0; i < comps.Length; i++) + { + var c = comps[i]; + for (var v = 0; v < c.V; v++) + { + var row = (my * c.V + v) * c.BlocksPerLine + mx * c.H; + for (var h = 0; h < c.H; h++) DecodeBlock(ref reader, kind, c, (row + h) * 64, i, ref state); + } + } + } + if (reader.Overrun) throw new JpegEntropyException("JPEG: premature end of entropy-coded data"); + } + } + catch (JpegEntropyException ex) + { + parser.Warn(ex.Message); + if (interval == 0) break; + mcu = end; + } + if (mcu >= total || interval == 0) break; + + var marker = reader.FindMarker(); + if (marker is < JpegTables.Rst0 or > JpegTables.Rst0 + 7) + { + parser.Warn("JPEG: restart marker missing; scan truncated"); + break; + } + var found = marker - JpegTables.Rst0; + if (found != expectedRst) + { + // Intervals between the expected and the found marker were lost: leave their blocks untouched. + var lost = (found - expectedRst) & 7; + parser.Warn($"JPEG: {lost} restart interval(s) lost"); + mcu += (long)lost * interval; + } + reader.AcceptMarker(); + expectedRst = (found + 1) & 7; + state.EobRun = 0; + foreach (var c in comps) c.DcPred = 0; + } + return reader.Position; + } + + private struct ScanState(JpegScan scan) + { + public readonly JpegScan Scan = scan; + public int EobRun; + } + + private static void DecodeBlock(ref JpegBitReader r, Kind kind, JpegComponent c, int offset, int index, ref ScanState state) + { + var block = c.Coefficients.AsSpan(offset, 64); + var scan = state.Scan; + switch (kind) + { + case Kind.Sequential: + DecodeSequential(ref r, block, scan.DcTables[index]!, scan.AcTables[index]!, ref c.DcPred); + break; + case Kind.DcFirst: + { + var t = r.Decode(scan.DcTables[index]!); + if (t > 16) throw new JpegEntropyException("JPEG: bad DC magnitude"); + c.DcPred += t == 0 ? 0 : r.Receive(t); + block[0] = (short)(c.DcPred * (1 << scan.Al)); + break; + } + case Kind.DcRefine: + if (r.ReadBit() != 0) block[0] |= (short)(1 << scan.Al); + break; + case Kind.AcFirst: + DecodeAcFirst(ref r, block, scan.AcTables[index]!, scan.Ss, scan.Se, scan.Al, ref state.EobRun); + break; + default: + DecodeAcRefine(ref r, block, scan.AcTables[index]!, scan.Ss, scan.Se, scan.Al, ref state.EobRun); + break; + } + } + + private static void DecodeSequential(ref JpegBitReader r, Span block, JpegHuffmanTable dc, JpegHuffmanTable ac, ref int pred) + { + var t = r.Decode(dc); + if (t > 16) throw new JpegEntropyException("JPEG: bad DC magnitude"); + pred += t == 0 ? 0 : r.Receive(t); + block[0] = (short)pred; + var order = JpegTables.NaturalOrder; + var fastAc = ac.FastAc; + var k = 1; + while (k < 64) + { + r.Ensure(16); + var fast = fastAc[r.Peek(JpegHuffmanTable.FastBits)]; + if (fast != 0) + { + k += (fast >> 8) & 15; + r.Consume(fast & 0xFF); + if (k > 63) throw new JpegEntropyException("JPEG: coefficient index out of range"); + block[order[k++]] = (short)(fast >> 16); + continue; + } + var rs = r.Decode(ac); + int run = rs >> 4, s = rs & 15; + if (s == 0) + { + if (run != 15) break; + k += 16; + continue; + } + k += run; + if (k > 63) throw new JpegEntropyException("JPEG: coefficient index out of range"); + block[order[k++]] = (short)r.Receive(s); + } + } + + private static void DecodeAcFirst(ref JpegBitReader r, Span block, JpegHuffmanTable ac, int ss, int se, int al, ref int eobRun) + { + if (eobRun > 0) + { + eobRun--; + return; + } + var order = JpegTables.NaturalOrder; + for (var k = ss; k <= se;) + { + var rs = r.Decode(ac); + int run = rs >> 4, s = rs & 15; + if (s == 0) + { + if (run < 15) + { + eobRun = (1 << run) - 1; + if (run > 0) eobRun += r.ReadBits(run); + return; + } + k += 16; + continue; + } + k += run; + if (k > 63) throw new JpegEntropyException("JPEG: coefficient index out of range"); + block[order[k++]] = (short)(r.Receive(s) * (1 << al)); + } + } + + /// AC successive-approximation refinement (T.81 G.1.2.3), following libjpeg's decode_mcu_AC_refine. + private static void DecodeAcRefine(ref JpegBitReader r, Span block, JpegHuffmanTable ac, int ss, int se, int al, ref int eobRun) + { + var order = JpegTables.NaturalOrder; + var p1 = (short)(1 << al); + var m1 = (short)(-1 << al); + var k = ss; + if (eobRun == 0) + { + for (; k <= se; k++) + { + var rs = r.Decode(ac); + int run = rs >> 4, s = rs & 15; + short value = 0; + if (s != 0) + { + if (s != 1) throw new JpegEntropyException("JPEG: bad refinement magnitude"); + value = r.ReadBit() != 0 ? p1 : m1; + } + else if (run != 15) + { + eobRun = 1 << run; + if (run > 0) eobRun += r.ReadBits(run); + break; + } + // Skip `run` still-zero coefficients, refining the non-zero ones passed on the way. + for (; k <= se; k++) + { + ref var coef = ref block[order[k]]; + if (coef != 0) + { + RefineBit(ref r, ref coef, p1, m1); + } + else + { + if (run == 0) break; + run--; + } + } + if (value != 0) + { + if (k > se) throw new JpegEntropyException("JPEG: refinement beyond spectral band"); + block[order[k]] = value; + } + } + } + if (eobRun > 0) + { + for (; k <= se; k++) + { + ref var coef = ref block[order[k]]; + if (coef != 0) RefineBit(ref r, ref coef, p1, m1); + } + eobRun--; + } + } + + private static void RefineBit(ref JpegBitReader r, ref short coef, short p1, short m1) + { + if (r.ReadBit() == 0 || (coef & p1) != 0) return; + coef += coef >= 0 ? p1 : m1; + } +} diff --git a/src/Titano.Core/Codecs/Jpeg/JpegTables.cs b/src/Titano.Core/Codecs/Jpeg/JpegTables.cs new file mode 100644 index 00000000..6e3d6f0a --- /dev/null +++ b/src/Titano.Core/Codecs/Jpeg/JpegTables.cs @@ -0,0 +1,96 @@ +namespace Titano.Core.Codecs.Jpeg; + +/// Constants shared by the JPEG encoder and decoders (ITU T.81 Annex K). +internal static class JpegTables +{ + public const byte Soi = 0xD8, Eoi = 0xD9, Sos = 0xDA, Dqt = 0xDB, Dnl = 0xDC, Dri = 0xDD, Dht = 0xC4, Dac = 0xCC; + public const byte Sof0 = 0xC0, Sof1 = 0xC1, Sof2 = 0xC2, Sof3 = 0xC3, Rst0 = 0xD0, App0 = 0xE0, App1 = 0xE1, App14 = 0xEE, Com = 0xFE; + + /// Natural (row-major) index of the coefficient at each zig-zag position. + public static ReadOnlySpan NaturalOrder => + [ + 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63, + ]; + + /// Annex K.1 luminance quantisation table, natural order. + public static ReadOnlySpan LumaQuant => + [ + 16, 11, 10, 16, 24, 40, 51, 61, + 12, 12, 14, 19, 26, 58, 60, 55, + 14, 13, 16, 24, 40, 57, 69, 56, + 14, 17, 22, 29, 51, 87, 80, 62, + 18, 22, 37, 56, 68, 109, 103, 77, + 24, 35, 55, 64, 81, 104, 113, 92, + 49, 64, 78, 87, 103, 121, 120, 101, + 72, 92, 95, 98, 112, 100, 103, 99, + ]; + + /// Annex K.1 chrominance quantisation table, natural order. + public static ReadOnlySpan ChromaQuant => + [ + 17, 18, 24, 47, 99, 99, 99, 99, + 18, 21, 26, 66, 99, 99, 99, 99, + 24, 26, 56, 99, 99, 99, 99, 99, + 47, 66, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + ]; + + public static ReadOnlySpan DcLumaBits => [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]; + public static ReadOnlySpan DcLumaValues => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]; + public static ReadOnlySpan DcChromaBits => [0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]; + public static ReadOnlySpan DcChromaValues => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]; + public static ReadOnlySpan AcLumaBits => [0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d]; + + public static ReadOnlySpan AcLumaValues => + [ + 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, + 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, + 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, + 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, + 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, + 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, + 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, + 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, + 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, + 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, + 0xf9, 0xfa, + ]; + + public static ReadOnlySpan AcChromaBits => [0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77]; + + public static ReadOnlySpan AcChromaValues => + [ + 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, + 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, + 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, + 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, + 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, + 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, + 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, + 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, + 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, + 0xf9, 0xfa, + ]; + + /// Orthonormal 8-point DCT basis: Basis[u * 8 + x] = c(u)/2 · cos((2x+1)uπ/16). + public static readonly float[] Basis = BuildBasis(8); + + /// DCT basis of an n-point reduced IDCT evaluated with 8-point normalisation (DCT-domain scaling). + public static float[] BuildBasis(int n) + { + var b = new float[n * n]; + for (var u = 0; u < n; u++) + { + var cu = u == 0 ? Math.Sqrt(0.5) : 1.0; + for (var x = 0; x < n; x++) b[u * n + x] = (float)(cu / 2 * Math.Cos((2 * x + 1) * u * Math.PI / (2 * n))); + } + return b; + } +} diff --git a/src/Titano.Core/Codecs/Jpeg/JpegTypes.cs b/src/Titano.Core/Codecs/Jpeg/JpegTypes.cs new file mode 100644 index 00000000..a8514b3b --- /dev/null +++ b/src/Titano.Core/Codecs/Jpeg/JpegTypes.cs @@ -0,0 +1,153 @@ +namespace Titano.Core.Codecs.Jpeg; + +/// JPEG coding process declared by the SOF marker. +public enum JpegProcess +{ + /// SOF0: baseline sequential DCT, 8-bit, at most two Huffman tables per class. + Baseline, + + /// SOF1: extended sequential DCT (8 or 12-bit). + ExtendedSequential, + + /// SOF2: progressive DCT (spectral selection and successive approximation). + Progressive, + + /// SOF3: lossless predictive coding (2–16 bit). + Lossless, +} + +/// Colour space of the encoded components. +public enum JpegColorSpace +{ + Gray, + YCbCr, + Rgb, + Cmyk, + Ycck, + + /// No defined colour interpretation (e.g. two-component lossless raw tiles). + Other, +} + +/// Overrides the colour interpretation of a 3- or 4-component stream (TIFF knows it out of band). +public enum JpegColorTransform +{ + /// JFIF/Adobe markers and component ids decide (libjpeg rules). + Auto, + + /// Components are stored as-is (RGB or CMYK). + None, + + /// Components are YCbCr (or YCCK for four components). + YCbCr, +} + +/// Frame facts from the headers, available without decoding pixels. +/// Full image width in pixels. +/// Full image height in pixels. +/// Number of encoded components (1–4). +/// Sample precision in bits (8 or 12 for DCT, 2–16 for lossless). +/// Coding process. +/// Colour space the decoder will assume. +/// Horizontal and vertical sampling factors per component. +/// Restart interval in MCUs declared before the first scan (0 = none). +public sealed record JpegInfo( + int Width, + int Height, + int Components, + int Precision, + JpegProcess Process, + JpegColorSpace ColorSpace, + IReadOnlyList<(int H, int V)> Sampling, + int RestartInterval) +{ + /// Chroma subsampling in J:a:b notation for three-component images ("4:2:0"), otherwise a factor list. + public string SamplingNotation + { + get + { + if (Sampling.Count == 3 && Sampling[1] == Sampling[2] && Sampling[1] == (1, 1)) + { + return Sampling[0] switch + { + (1, 1) => "4:4:4", + (2, 1) => "4:2:2", + (2, 2) => "4:2:0", + (1, 2) => "4:4:0", + (4, 1) => "4:1:1", + (4, 2) => "4:1:0", + _ => Factors(), + }; + } + return Factors(); + } + } + + private string Factors() => string.Join(",", Sampling.Select(s => $"{s.H}x{s.V}")); +} + +/// Options for . +public sealed record JpegDecodeOptions +{ + /// Default options: full size, fancy upsampling, automatic colour transform. + public static JpegDecodeOptions Default { get; } = new(); + + /// When > 0, decode with the smallest DCT-domain reduction (1/2, 1/4, 1/8) whose long edge is still + /// ≥ this value. 0 decodes at full size. Ignored for lossless streams. + public int MaxLongEdge { get; init; } + + /// Triangle-filter chroma upsampling (libjpeg "fancy"); false replicates chroma samples. + public bool FancyUpsampling { get; init; } = true; + + /// Colour interpretation override (TIFF photometric). + public JpegColorTransform ColorTransform { get; init; } = JpegColorTransform.Auto; + + /// Abbreviated table-specification stream (TIFF JPEGTables) parsed before the image stream. + public byte[]? Tables { get; init; } + + /// Upper bound on width × height; larger frames are rejected before any allocation. + public long MaxPixels { get; init; } = 1L << 28; + + /// Worker limit for the IDCT and colour stages (-1 = all cores, 1 = single-threaded). + public int MaxDegreeOfParallelism { get; init; } = -1; +} + +/// Decoded JPEG pixels, interleaved, top-down, Exif orientation not applied. +public sealed class JpegImage +{ + internal JpegImage(JpegInfo info, int width, int height, int components, int bitDepth, byte[]? pixels8, ushort[]? pixels16, IReadOnlyList warnings) + { + Info = info; + Width = width; + Height = height; + Components = components; + BitDepth = bitDepth; + Pixels8 = pixels8; + Pixels16 = pixels16; + Warnings = warnings; + } + + /// Header facts of the source stream (full-size dimensions). + public JpegInfo Info { get; } + + /// Output width (smaller than when DCT scaling was used). + public int Width { get; } + + public int Height { get; } + + /// Output channels: 1 (gray) or 3 (RGB; CMYK/YCCK are converted). + public int Components { get; } + + /// Significant bits per sample: 8 → ; more → with values 0..2^BitDepth−1. + public int BitDepth { get; } + + public byte[]? Pixels8 { get; } + + public ushort[]? Pixels16 { get; } + + /// Recoverable problems (corrupt entropy data, missing restart markers, truncation). + public IReadOnlyList Warnings { get; } +} + +/// Raw samples of a lossless (SOF3) stream as encoded: interleaved, as in the frame header. +public readonly record struct JpegLosslessImage(ushort[] Samples, int Width, int Height, int Components, int Precision); diff --git a/src/Titano.Core/Imaging/PixelConvert.cs b/src/Titano.Core/Imaging/PixelConvert.cs new file mode 100644 index 00000000..4a416d6a --- /dev/null +++ b/src/Titano.Core/Imaging/PixelConvert.cs @@ -0,0 +1,390 @@ +using System.Numerics; +using System.Runtime.CompilerServices; + +namespace Titano.Core.Imaging; + +/// How integer samples relate to light: sRGB-encoded (display referred) or proportional to linear light. +public enum TransferFunction +{ + Srgb, + Linear, +} + +/// +/// Conversions between interleaved integer pixels and planar linear-light s, gray ↔ RGB, +/// Exif orientation, and clamping. Interleaved layouts: 1 = gray, 2 = gray+alpha, 3 = RGB, 4 = RGBA. Alpha is +/// never transfer-encoded. Row loops are parallel for large images. +/// +public static class PixelConvert +{ + private const int ParallelThreshold = 1 << 16; + + /// 8×8 Bayer thresholds in code units, centred on zero (ordered dither). + private static readonly float[] Bayer = BuildBayer(); + + /// Interleaved 8-bit samples → linear buffer. + /// 0 = natural (1/2 → 1, 3 → 3, 4 → 3); 3 expands gray; 4 keeps alpha. + public static ImageBuffer FromInterleaved8(ReadOnlySpan pixels, int width, int height, int channels, TransferFunction transfer = TransferFunction.Srgb, int outputChannels = 0) + { + var outCh = OutputChannels(channels, outputChannels); + CheckLength(pixels.Length, width, height, channels); + var lut = new float[256]; + for (var i = 0; i < 256; i++) lut[i] = transfer == TransferFunction.Srgb ? ColorSpace.Linear8((byte)i) : i / 255f; + var image = new ImageBuffer(width, height, outCh, clear: false); + unsafe + { + fixed (byte* p = pixels) + { + var ptr = (nint)p; + ForRows(height, width, y => + { + var row = new ReadOnlySpan((byte*)ptr + (long)y * width * channels, width * channels); + Scatter(row, image, y, channels, lut, 1f / 255f); + }); + } + } + return image; + } + + /// Interleaved 16-bit container samples (values 0..) → linear buffer. + public static ImageBuffer FromInterleaved16(ReadOnlySpan pixels, int width, int height, int channels, TransferFunction transfer = TransferFunction.Srgb, int maxValue = 65535, int outputChannels = 0) + { + if (maxValue is < 1 or > 65535) throw new ArgumentOutOfRangeException(nameof(maxValue)); + var outCh = OutputChannels(channels, outputChannels); + CheckLength(pixels.Length, width, height, channels); + var lut = new float[maxValue + 1]; + for (var i = 0; i <= maxValue; i++) + { + lut[i] = transfer == TransferFunction.Linear ? i / (float)maxValue + : maxValue == 65535 ? ColorSpace.Linear16((ushort)i) : (float)ColorSpace.SrgbToLinear(i / (double)maxValue); + } + var alphaScale = 1f / maxValue; + var image = new ImageBuffer(width, height, outCh, clear: false); + unsafe + { + fixed (ushort* p = pixels) + { + var ptr = (nint)p; + ForRows(height, width, y => + { + var row = new ReadOnlySpan((ushort*)ptr + (long)y * width * channels, width * channels); + Scatter(row, image, y, channels, lut, alphaScale); + }); + } + } + return image; + } + + /// Linear buffer → interleaved 8-bit samples with per pixel + /// (1 from RGB takes Rec.709 luminance; missing alpha is opaque). + /// Add 8×8 ordered dither before rounding (breaks banding in smooth gradients). + public static void ToInterleaved8(ImageBuffer image, Span destination, int channels, TransferFunction transfer = TransferFunction.Srgb, bool dither = false) + { + CheckLength(destination.Length, image.Width, image.Height, channels); + unsafe + { + fixed (byte* p = destination) + { + var ptr = (nint)p; + ForRows(image.Height, image.Width, y => + { + var row = new Span((byte*)ptr + (long)y * image.Width * channels, image.Width * channels); + EncodeRow8(image, y, row, channels, transfer, dither); + }); + } + } + } + + /// Allocating overload of . + public static byte[] ToInterleaved8(ImageBuffer image, int channels, TransferFunction transfer = TransferFunction.Srgb, bool dither = false) + { + var result = new byte[checked(image.Width * image.Height * channels)]; + ToInterleaved8(image, result, channels, transfer, dither); + return result; + } + + /// Linear buffer → interleaved 16-bit samples (0..65535). + public static void ToInterleaved16(ImageBuffer image, Span destination, int channels, TransferFunction transfer = TransferFunction.Srgb) + { + CheckLength(destination.Length, image.Width, image.Height, channels); + unsafe + { + fixed (ushort* p = destination) + { + var ptr = (nint)p; + ForRows(image.Height, image.Width, y => + { + var row = new Span((ushort*)ptr + (long)y * image.Width * channels, image.Width * channels); + EncodeRow16(image, y, row, channels, transfer); + }); + } + } + } + + /// Allocating overload of . + public static ushort[] ToInterleaved16(ImageBuffer image, int channels, TransferFunction transfer = TransferFunction.Srgb) + { + var result = new ushort[checked(image.Width * image.Height * channels)]; + ToInterleaved16(image, result, channels, transfer); + return result; + } + + /// Encodes row into interleaved 8-bit samples (codec edge helper). + internal static void EncodeRow8(ImageBuffer image, int y, Span row, int channels, TransferFunction transfer, bool dither) + { + var w = image.Width; + Span offsets = stackalloc float[8]; + if (dither) + { + for (var i = 0; i < 8; i++) offsets[i] = 0.5f + Bayer[(y & 7) * 8 + i]; + } + else + { + offsets.Fill(0.5f); + } + var srgb = transfer == TransferFunction.Srgb; + var colour = channels is 1 or 2 ? 1 : 3; + for (var c = 0; c < channels; c++) + { + if (c == colour) + { + var a = image.Channels == 4 ? image.Row(3, y) : default; + for (var x = 0; x < w; x++) row[x * channels + c] = a.IsEmpty ? (byte)255 : (byte)(Math.Clamp(a[x], 0f, 1f) * 255f + 0.5f); + continue; + } + var src = SourceRow(image, y, c, colour, out var luminance); + for (var x = 0; x < w; x++) + { + var v = luminance is null ? src[x] : luminance[x]; + var e = srgb ? ColorSpace.EncodeFast(v) : Math.Clamp(v, 0f, 1f); + row[x * channels + c] = (byte)Math.Clamp(e * 255f + offsets[x & 7], 0f, 255f); + } + } + } + + /// Encodes row into interleaved 16-bit samples (codec edge helper). + internal static void EncodeRow16(ImageBuffer image, int y, Span row, int channels, TransferFunction transfer) + { + var w = image.Width; + var srgb = transfer == TransferFunction.Srgb; + var colour = channels is 1 or 2 ? 1 : 3; + for (var c = 0; c < channels; c++) + { + if (c == colour) + { + var a = image.Channels == 4 ? image.Row(3, y) : default; + for (var x = 0; x < w; x++) row[x * channels + c] = a.IsEmpty ? (ushort)65535 : (ushort)(Math.Clamp(a[x], 0f, 1f) * 65535f + 0.5f); + continue; + } + var src = SourceRow(image, y, c, colour, out var luminance); + for (var x = 0; x < w; x++) + { + var v = luminance is null ? src[x] : luminance[x]; + row[x * channels + c] = srgb ? ColorSpace.Encode16(v) : (ushort)(Math.Clamp(v, 0f, 1f) * 65535f + 0.5f); + } + } + } + + /// Single-channel buffer replicated into three channels. + public static ImageBuffer GrayToRgb(ImageBuffer gray) + { + if (gray.Channels != 1) throw new ArgumentException("Expected one channel", nameof(gray)); + var rgb = new ImageBuffer(gray.Width, gray.Height, 3, clear: false); + for (var c = 0; c < 3; c++) gray.Plane(0).CopyTo(rgb.Plane(c)); + return rgb; + } + + /// Rec.709 luminance of an RGB(A) buffer. + public static ImageBuffer RgbToGray(ImageBuffer rgb) + { + if (rgb.Channels < 3) throw new ArgumentException("Expected RGB", nameof(rgb)); + var gray = new ImageBuffer(rgb.Width, rgb.Height, 1, clear: false); + var r = rgb.Plane(0); + var g = rgb.Plane(1); + var b = rgb.Plane(2); + var d = gray.Plane(0); + var i = 0; + if (Vector.IsHardwareAccelerated) + { + var wr = new Vector(ColorSpace.LumaR); + var wg = new Vector(ColorSpace.LumaG); + var wb = new Vector(ColorSpace.LumaB); + for (; i <= d.Length - Vector.Count; i += Vector.Count) + { + (new Vector(r[i..]) * wr + new Vector(g[i..]) * wg + new Vector(b[i..]) * wb).CopyTo(d[i..]); + } + } + for (; i < d.Length; i++) d[i] = ColorSpace.Luminance(r[i], g[i], b[i]); + return gray; + } + + /// Clamps every value into [, ] (NaN becomes ). + public static void Clamp(Span values, float min = 0f, float max = 1f) + { + var i = 0; + if (Vector.IsHardwareAccelerated) + { + var lo = new Vector(min); + var hi = new Vector(max); + for (; i <= values.Length - Vector.Count; i += Vector.Count) + { + var v = new Vector(values[i..]); + // Max(v, lo) with v as the first operand maps NaN to lo on x86 (maxps returns the second operand). + Vector.Min(Vector.ConditionalSelect(Vector.Equals(v, v), Vector.Max(v, lo), lo), hi).CopyTo(values[i..]); + } + } + for (; i < values.Length; i++) + { + var v = values[i]; + values[i] = float.IsNaN(v) ? min : Math.Clamp(v, min, max); + } + } + + /// Size after applying an Exif orientation (5–8 swap width and height). + public static (int Width, int Height) OrientedSize(int width, int height, int orientation) => + orientation is >= 5 and <= 8 ? (height, width) : (width, height); + + /// Applies an Exif orientation (1–8) into a new buffer; other values are treated as 1 (copy). + public static ImageBuffer ApplyOrientation(ImageBuffer source, int orientation) + { + int w = source.Width, h = source.Height; + var (ow, oh) = OrientedSize(w, h, orientation); + var result = new ImageBuffer(ow, oh, source.Channels, clear: false); + if (orientation is < 2 or > 8) + { + source.CopyTo(result); + return result; + } + for (var c = 0; c < source.Channels; c++) + { + var src = source.Storage.AsMemory(c * source.PlaneLength, source.PlaneLength); + var dst = result.Storage.AsMemory(c * result.PlaneLength, result.PlaneLength); + if (orientation <= 4) + { + ForRows(oh, ow, y => + { + var sy = orientation is 3 or 4 ? h - 1 - y : y; + var s = src.Span.Slice(sy * w, w); + var d = dst.Span.Slice(y * ow, ow); + s.CopyTo(d); + if (orientation is 2 or 3) d.Reverse(); + }); + continue; + } + // Transposing orientations: copy in 32×32 tiles so both sides stay cache-friendly. + const int tile = 32; + var tilesY = (oh + tile - 1) / tile; + ForRows(tilesY, ow * tile, ty => + { + var s = src.Span; + var d = dst.Span; + var y1 = Math.Min(oh, (ty + 1) * tile); + for (var x0 = 0; x0 < ow; x0 += tile) + { + var x1 = Math.Min(ow, x0 + tile); + for (var y = ty * tile; y < y1; y++) + { + for (var x = x0; x < x1; x++) + { + var (sx, sy) = orientation switch + { + 5 => (y, x), + 6 => (y, h - 1 - x), + 7 => (w - 1 - y, h - 1 - x), + _ => (w - 1 - y, x), + }; + d[y * ow + x] = s[sy * w + sx]; + } + } + } + }); + } + return result; + } + + private static ReadOnlySpan SourceRow(ImageBuffer image, int y, int c, int colourChannels, out float[]? luminance) + { + luminance = null; + if (image.Channels == 1) return image.Row(0, y); + if (colourChannels == 3) return image.Row(c, y); + var r = image.Row(0, y); + var g = image.Row(1, y); + var b = image.Row(2, y); + luminance = new float[image.Width]; + for (var x = 0; x < luminance.Length; x++) luminance[x] = ColorSpace.Luminance(r[x], g[x], b[x]); + return default; + } + + /// De-interleaves one row: colour through (indices clamped to its range), alpha scaled. + private static void Scatter(ReadOnlySpan row, ImageBuffer image, int y, int channels, float[] lut, float alphaScale) + where T : unmanaged, IBinaryInteger + { + var w = image.Width; + var top = lut.Length - 1; + var colour = channels is 1 or 2 ? 1 : 3; + for (var c = 0; c < image.Channels; c++) + { + var dst = image.Row(c, y); + if (c == 3) + { + if (channels is 2 or 4) + { + var a = channels - 1; + for (var x = 0; x < w; x++) dst[x] = Math.Min(int.CreateTruncating(row[x * channels + a]), top) * alphaScale; + } + else + { + dst.Fill(1f); + } + continue; + } + var s = colour == 1 ? 0 : c; + for (var x = 0; x < w; x++) dst[x] = lut[Math.Min(int.CreateTruncating(row[x * channels + s]), top)]; + } + } + + private static int OutputChannels(int channels, int requested) + { + if (channels is < 1 or > 4) throw new ArgumentOutOfRangeException(nameof(channels)); + if (requested is not (0 or 1 or 3 or 4)) throw new ArgumentOutOfRangeException(nameof(requested)); + if (requested == 1 && channels > 2) throw new ArgumentException("Use RgbToGray to reduce colour to one channel", nameof(requested)); + return requested != 0 ? requested : channels <= 2 ? 1 : 3; + } + + private static void CheckLength(int length, int width, int height, int channels) + { + ArgumentOutOfRangeException.ThrowIfNegativeOrZero(width); + ArgumentOutOfRangeException.ThrowIfNegativeOrZero(height); + if (channels is < 1 or > 4) throw new ArgumentOutOfRangeException(nameof(channels)); + if (length < (long)width * height * channels) throw new ArgumentException("Pixel buffer too small"); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ForRows(int rows, int rowWork, Action body) + { + if ((long)rows * rowWork < ParallelThreshold) + { + for (var y = 0; y < rows; y++) body(y); + } + else + { + Parallel.For(0, rows, body); + } + } + + private static float[] BuildBayer() + { + // Recursive Bayer matrix: interleave bits of (x ^ y) and y, least significant coordinate bits first. + var m = new float[64]; + for (var y = 0; y < 8; y++) + { + for (var x = 0; x < 8; x++) + { + var v = 0; + for (var bit = 0; bit < 3; bit++) v = v << 2 | (((x ^ y) >> bit) & 1) << 1 | ((y >> bit) & 1); + m[y * 8 + x] = (v + 0.5f) / 64f - 0.5f; + } + } + return m; + } +} diff --git a/tests/Titano.Core.Tests/Codecs/CodecTestData.cs b/tests/Titano.Core.Tests/Codecs/CodecTestData.cs new file mode 100644 index 00000000..3f637bd4 --- /dev/null +++ b/tests/Titano.Core.Tests/Codecs/CodecTestData.cs @@ -0,0 +1,167 @@ +using System.Text; +using Titano.Testing; + +namespace Titano.Core.Tests.Codecs; + +/// Shared fixtures, synthetic images and image metrics for codec tests. +internal static class CodecTestData +{ + public static byte[] Fixture(string relativePath) => + File.ReadAllBytes(Path.Combine(TestContext.FixturesDirectory, "codecs", relativePath)); + + /// Netpbm P5/P6/P7 (PAM) reader for reference images; samples are big-endian when maxval > 255. + public static Pnm ReadPnm(byte[] data) + { + var pos = 0; + string Token() + { + while (pos < data.Length && (char.IsWhiteSpace((char)data[pos]) || data[pos] == '#')) + { + if (data[pos] == '#') while (pos < data.Length && data[pos] != '\n') pos++; + else pos++; + } + var start = pos; + while (pos < data.Length && !char.IsWhiteSpace((char)data[pos])) pos++; + return Encoding.ASCII.GetString(data, start, pos - start); + } + var magic = Token(); + int width, height, channels, maxVal; + if (magic == "P7") + { + width = height = channels = maxVal = 0; + for (var t = Token(); t != "ENDHDR"; t = Token()) + { + switch (t) + { + case "WIDTH": width = int.Parse(Token()); break; + case "HEIGHT": height = int.Parse(Token()); break; + case "DEPTH": channels = int.Parse(Token()); break; + case "MAXVAL": maxVal = int.Parse(Token()); break; + case "TUPLTYPE": Token(); break; + } + } + } + else + { + channels = magic switch { "P5" => 1, "P6" => 3, _ => throw new InvalidDataException(magic) }; + width = int.Parse(Token()); + height = int.Parse(Token()); + maxVal = int.Parse(Token()); + } + pos++; + var samples = new int[width * height * channels]; + for (var i = 0; i < samples.Length; i++) + { + samples[i] = maxVal > 255 ? data[pos + 2 * i] << 8 | data[pos + 2 * i + 1] : data[pos + i]; + } + return new Pnm(width, height, channels, maxVal, samples); + } + + public sealed record Pnm(int Width, int Height, int Channels, int MaxVal, int[] Samples) + { + public byte[] Bytes => Samples.Select(s => (byte)s).ToArray(); + public ushort[] Words => Samples.Select(s => (ushort)s).ToArray(); + } + + /// Deterministic RGB test card: smooth gradients, saturated colour bars, seeded noise and + /// text-like one-pixel strokes (the four content classes codecs struggle with). + public static byte[] TestCard(int width, int height, int seed = 1) + { + var rng = new Random(seed); + var rgb = new byte[width * height * 3]; + for (var y = 0; y < height; y++) + { + for (var x = 0; x < width; x++) + { + var band = y * 4 / height; + int r, g, b; + switch (band) + { + case 0: + r = x * 255 / Math.Max(1, width - 1); + g = y * 4 * 255 / Math.Max(1, height - 1) / 4 * 4 % 256; + b = 255 - r; + break; + case 1: + var bar = x * 8 / width; + r = (bar & 4) != 0 ? 230 : 25; + g = (bar & 2) != 0 ? 230 : 25; + b = (bar & 1) != 0 ? 230 : 25; + break; + case 2: + r = rng.Next(256); + g = rng.Next(256); + b = rng.Next(256); + break; + default: + var stroke = x % 7 == 0 || y % 9 == 0 || (x + y) % 13 == 0; + r = g = b = stroke ? 20 : 235; + break; + } + var i = (y * width + x) * 3; + rgb[i] = (byte)r; + rgb[i + 1] = (byte)g; + rgb[i + 2] = (byte)b; + } + } + return rgb; + } + + /// Smooth photographic-like content (low-frequency gradients); compresses like real photos. + public static byte[] SmoothImage(int width, int height) + { + var rgb = new byte[width * height * 3]; + for (var y = 0; y < height; y++) + { + for (var x = 0; x < width; x++) + { + double u = x / (double)width, v = y / (double)height; + var i = (y * width + x) * 3; + rgb[i] = (byte)(127.5 + 120 * Math.Sin(6.1 * u + 2.3 * v)); + rgb[i + 1] = (byte)(127.5 + 120 * Math.Cos(4.7 * u * v + 3.1 * v)); + rgb[i + 2] = (byte)(127.5 + 120 * Math.Sin(9.3 * v - 1.7 * u + 0.5)); + } + } + return rgb; + } + + public static double Psnr(ReadOnlySpan a, ReadOnlySpan b) => Psnr(a, b, 255); + + public static double Psnr(ReadOnlySpan a, ReadOnlySpan b, double peak) where T : struct, IConvertible + { + Assert.Equal(a.Length, b.Length, "sample count"); + double sum = 0; + for (var i = 0; i < a.Length; i++) + { + var d = a[i].ToDouble(null) - b[i].ToDouble(null); + sum += d * d; + } + var mse = sum / a.Length; + return mse == 0 ? 99 : 10 * Math.Log10(peak * peak / mse); + } + + public static int MaxAbsDiff(ReadOnlySpan a, ReadOnlySpan b) + { + Assert.Equal(a.Length, b.Length, "sample count"); + var max = 0; + for (var i = 0; i < a.Length; i++) max = Math.Max(max, Math.Abs(a[i] - b[i])); + return max; + } + + /// Seeded corruption: the input truncated at points plus single-byte flips. + public static IEnumerable Corruptions(byte[] valid, int cases, int seed) + { + var rng = new Random(seed); + for (var i = 0; i < cases; i++) + { + yield return valid.AsSpan(0, rng.Next(valid.Length)).ToArray(); + var flipped = (byte[])valid.Clone(); + var flips = 1 + rng.Next(4); + for (var f = 0; f < flips; f++) flipped[rng.Next(flipped.Length)] ^= (byte)(1 << rng.Next(8)); + yield return flipped; + var garbage = (byte[])valid.Clone(); + garbage[rng.Next(garbage.Length)] = (byte)rng.Next(256); + yield return garbage; + } + } +} diff --git a/tests/Titano.Core.Tests/Codecs/JpegDecoderTests.cs b/tests/Titano.Core.Tests/Codecs/JpegDecoderTests.cs new file mode 100644 index 00000000..d161083c --- /dev/null +++ b/tests/Titano.Core.Tests/Codecs/JpegDecoderTests.cs @@ -0,0 +1,79 @@ +using Titano.Core.Codecs.Jpeg; +using Titano.Testing; +using static Titano.Core.Tests.Codecs.CodecTestData; + +namespace Titano.Core.Tests.Codecs; + +/// Decoder output against libjpeg-turbo's djpeg (accurate integer IDCT) on cjpeg-produced fixtures. +public sealed class JpegDecoderTests(TestContext context) +{ + [Theory] + [Case("b444", "4:4:4")] + [Case("b422", "4:2:2")] + [Case("b420", "4:2:0")] + [Case("b440", "4:4:0")] + [Case("b411", "4:1:1")] + [Case("p420", "4:2:0")] + [Case("p444", "4:4:4")] + [Case("r420", "4:2:0")] + [Case("r444", "4:4:4")] + public void MatchesDjpeg(string name, string sampling) + { + var data = Fixture($"jpeg/{name}.jpg"); + var reference = ReadPnm(Fixture($"jpeg/{name}.ppm")); + var image = JpegDecoder.Decode(data); + Assert.Equal(reference.Width, image.Width); + Assert.Equal(reference.Height, image.Height); + Assert.Equal(3, image.Components); + Assert.Equal(sampling, image.Info.SamplingNotation); + Assert.Empty(image.Warnings); + var diff = MaxAbsDiff(image.Pixels8, reference.Samples); + context.Log($"{name}: max |diff| = {diff}"); + Assert.LessOrEqual(diff, 2); + } + + [Theory] + [Case("gray")] + [Case("pgray")] + public void GrayMatchesDjpeg(string name) + { + var image = JpegDecoder.Decode(Fixture($"jpeg/{name}.jpg")); + var reference = ReadPnm(Fixture($"jpeg/{name}.pgm")); + Assert.Equal(1, image.Components); + Assert.Equal(JpegColorSpace.Gray, image.Info.ColorSpace); + Assert.LessOrEqual(MaxAbsDiff(image.Pixels8, reference.Samples), 2); + } + + [Test] + public void ReplicatedUpsamplingMatchesDjpegNoSmooth() + { + var image = JpegDecoder.Decode(Fixture("jpeg/b420.jpg"), new JpegDecodeOptions { FancyUpsampling = false }); + Assert.LessOrEqual(MaxAbsDiff(image.Pixels8, ReadPnm(Fixture("jpeg/b420-nosmooth.ppm")).Samples), 2); + } + + [Test] + public void ReadInfoParsesHeadersOnly() + { + var info = JpegDecoder.ReadInfo(Fixture("jpeg/p420.jpg")); + Assert.Equal(61, info.Width); + Assert.Equal(45, info.Height); + Assert.Equal(JpegProcess.Progressive, info.Process); + Assert.Equal(JpegColorSpace.YCbCr, info.ColorSpace); + Assert.Equal(8, info.Precision); + var restart = JpegDecoder.ReadInfo(Fixture("jpeg/r444.jpg")); + Assert.Equal(5, restart.RestartInterval); + } + + [Test] + public void AdobeYcckIsConvertedToRgb() + { + var image = JpegDecoder.Decode(Fixture("jpeg/cmyk.jpg")); + Assert.Equal(JpegColorSpace.Ycck, image.Info.ColorSpace); + Assert.Equal(4, image.Info.Components); + Assert.Equal(3, image.Components); + var source = ReadPnm(Fixture("src.ppm")); + var psnr = Psnr(image.Pixels8, source.Bytes); + context.Log($"YCCK round trip PSNR {psnr:F1} dB"); + Assert.Greater(psnr, 30); + } +} diff --git a/tests/fixtures/codecs/jpeg/b411.jpg b/tests/fixtures/codecs/jpeg/b411.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7331b1e5c601901df5aa4f3e685bc9fa5f23aaa0 GIT binary patch literal 2169 zcmbW!dpOg59|!Q??BL9nY|extNrlKFH?kViqnZ$j4r0V+nTicbMrh<1w>w%AI$#cW zVs4Rjk|9jUIZ;kwj=y{Axt`~`p1+>wd4I3(=b!KA`@KG|>kD>)p8=#D4vzyM5CDJ( z7XbDEHUJDNjL1fX!C-KN1OfqvBc#N{MI~gUWMyQeq@`t1XgOJ=JW5(xPDxH4qoAm$ zD7#5nRarq5t)Qr|@d!kC6#+*`A`p@aNNJ?P{~VA5pu~WkfCUs{1&E*^P!t4w38)L_ zghPG?_-7y@P~niGV&W2#!Ui@H5P|%h9u9}Wgx%r7a{z{dZ`!iQ3L)p@C8|l$J9!H#tgN0xeW1ZQZ7$yIs$CuZihCGpx-)Til_;c)Q~#2+k*6T;0x| zJAc9FqOV^t<#Gr$^vc!i(Kljl#xmlPQ|_durDtSj<>lXJJt%ls_^7n3oLx~_RsH8* z4KEv;UNv)H^V-@wK6Z9>^9KfphDS!nzKnmJnVtJFzpyA+THbI$0O&84u>OMmhYKZi ziNIh`nCONJB0?2zC<+GOvInur%1P9VB&TT@DYn^~dGA@hxR%keX?bsQs{~rxcwp4O7cr%Y?39mrDv7rqb6AjeBz4&;L%` zd33x_ZqNcqL5%%*6OO=fy{#TFCxXakOtlPuP_loiH6yQm6e91Iu`GHtk+G>NK}%%AS{KW&PUFHK$0^%CTSpkqMTjYNx7TZ zzu!CNyJ-lA%MsOyI1*U@nMe&P8YxrbMET8z!hajx1sEdOZkuV3s}>FzSZ!A1x=E0@u(T zYsa(cq8cC|vulna(21o_g&v)uJw0%_TsV`!av~1|u=BY$a%Y{(b5{aDAn$Z-4i5x| zcVLEA6DWkGTFZ5uqUl;_5eTr#mOC5O7vpHTg-ggV$-&m*1{U4h@zPj)OX6O=V6{`D z&HJFk+R32`7GgT&{(~Kli`m2~%F1;_O5@}Wli0+;s<9~~AyP7VcQCIu#S&Sg=tU$x z>Lq@hxHxaj!k0?Y1rr#zpR+t{d|7BuZ`Vv z6`xcNtO#&4Dj&M{q_xbfsoXI3IF*9ldSZPdCp#>Mcg^$ddeD%8%)2=iXEhf$^Vgd? z`{LNuo~{Or$Z8Af8m4gtW^VYU1}S{#XA4%hAqGjB8Z@MU=tdA3&!#kJxmO{HJB zW@2DCoc(srd(!m}QB;4LahPGd!Q-7Jt4>Ns0+USk$Gd($&poq`qS{fXCkQ)zicysC zM$g*xM4{cL4&UwXs!HbTQh5_+m(>$zjOVWY=!4IFsj1a@u<%Jh9^@bXF|npJak!#} z*}fyR${gl920e%Sj4JncNk2o;`KJ9D-Q$`@GDt7zS7fnUH7f{e4j*#*v^)m75PPm` zFf}FaImGn^aW6^wTLnw!~^;Zw{>-s>?hkh68Q_AcTX-n z;nJRa6r61$vexNIrfV;z*PnQ28@XSc)z1oNzbLZ}x(k!btQ*ie$pM<{;UCC7(Pt`` zCui|zDsGkWPy2;n<#UEjLwqF!E@>y)x-*j4#-dk?suLs<@vK60&_FLBDlW&VPeKpM|3EGhwmiq$;Fi6C%`#k?|V_DLs4ex>?l;1pe1_4I3 z(>q=cx5_M_o4eBYsaMIa#8!;=ZQy7o&-?_E!hynaSjz5N|`n>HEP zQx$Ed{e16{LcIKwTPgL-m#?fULtKjcth?`MKQ7zz{j2veF-fjj^M0ZorNb`q?ic>N zogO}nRkC=^LV{%H9#3S?+Go{Xtt8p|Q8Dpl*K#2P{%I%;_YG#`NqA}iWfoJ|Kt$SvQPD_mXfKemwz!e`%PTl4Z z1mSR0x!X!_z@15~UF_!EtcTzB_V?9=A864%9#y2~u1QtM`adBN$pAL5a4Tgr^ A&j0`b literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/b411.ppm b/tests/fixtures/codecs/jpeg/b411.ppm new file mode 100644 index 0000000000000000000000000000000000000000..e05451f934756db614eb5e00da121ae3b9459c77 GIT binary patch literal 8248 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 z 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 literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/b420.jpg b/tests/fixtures/codecs/jpeg/b420.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0181451ddc96c4775df870307f6ce0cb2820d3ca GIT binary patch literal 2265 zcmbW!c{tSH9tZI6n9V-MGK|uMks=La$rhy|Bt&Qwm7VN0C_+eODWfb?@{_E^giM$k z$Oa9;sPen1V_2L>qsd`J)&3F0;Z7~Y&v z(C+|$2gC>F4GHHL5ESBFs1^hGK)%4&|M@RJ62p_Uh{CA3Su})a;14g`NEg2S=xq1UGjN zPcLsD-_Q#eiDBUpm*V0Rt|eZ-ag&sO=Wa%3RyO%z{-c7zqT-U$%BpA8)aNy|b*~$n znp@s5THAVh-}m(o41QpaPfSit&&+=MJh$|1nZ2_5eQo{6FBb>^|6%d!AJ~7nkUSS3 z1OkS@f4M+>VZ04SLZI>*F!2Mn@Uy`Z3iw!lNt3j^iUt8i&EqVob0OV=D6H1F($X*5 zZ`uC_yZVo0|Azg?#RP=GAl~PJk$^G4%A#YUdl5b5%`DDl)|I=96{C@R~)_b0EvqN^y2dWYWz8Rz1*50CpLQO2ExB!FY{dcp& zf10tAjbyspp|S}#lw%C1W>+59vyyzo_AgsUc}RK}-l(V znKnJ;Z_v|0AeC1V$qTxl{8;s(tiGqUL>1lZx_a6H?tSYI*Zrf`>zuD7F0YxZNuV-5h+#Vb@Q)(&E z72i$RI<74p{sA?7&132|9-oZI>wcFSTSK&rqTWT?=7m!n`sJzJi&*l`^6Zmw>ZylX z-U*2wn9~<#&%7Ka@5vPOl2lPWcA@lJQGVv))HCOo7kbO@<$gvWJ+oA5^hq9P^ z8>NJOEh3=!3b9iJx=nAmNZRwp6pDW=nqGSIEl)^F9x>N>#^RdHIL(&cY?JF1nMd) z?+`ATAUrA5qUC-~A;Lv_H`wUVzW%aH1!Xjh=qYFOZ8_2Tr+rWZB>jXyX?RSE;m7mW zhxv3;lEmjl<9|N7&o|_U?^5bvb0)Q@by$bC{8q9At;z3&0nnoEE{;85zbnnT3$51R zU;8Xa`pDV}ywO=s!~X*9-pPP+qjtqzKK)>QMnaOln2kstHEig;OaMEB#s%W(U49fi zM%dZK#Ye$A!!*7@F$T>TUFYbFIg$8hjdi~E_2p@sSPWbtes}AdA4;zzG}m9U9?q?~ zRUG8&()l%P8})^wrsHUEC-4D??^Gq*)r&S`e2x3h*Fc03Yk&To5Yw?JXd6N=4^tZ;6s~+pp~vU{hyu5 zs0Z?7ESU?~*7)gpxMr#}Gl&OkWe;#F>H{XkrbzRBIt5q&=IL-yyAI~3+;y6=qoAzr&CKvD> zgKyBZJGp>>EFFNE^6!bu7*>SV4|tI*q0c-X^eo#|ynFIh zo>q0l@pV&W;e(E*sFJ@7`c8Lv+xyFiE2J+cH=v3aCS1`d&7b)V)ItLR+xIZ1?+l?x zT6UHAR+>6vO5IDunPX>@*dQ<|x5vJ6U_~B0I#%o%ahpDp8}4Qh>((m2f1)aVy70?B zty%hFHz|q8{7f@77S8`_J*L#TlVetS>@?1s?yykZ+l{+sIhy&xwT3P&?Z7-daD$@V zs$9kKT792v@_D}FiGq)U;rt0~>~>=V{}T{U4DM0S`Gr}s$lk`zpqMS~GzTtlqt>>w zC#SVW&;LU!XLNXld^h1iCgrm%*0$}3XN7;T=Aj-W)bC*ROT6NEi@0Za^LP?|*hcaT!{qQdo?G&{D literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/b420.ppm b/tests/fixtures/codecs/jpeg/b420.ppm new file mode 100644 index 0000000000000000000000000000000000000000..4fada5ab5b4e6f186d7dd6d67951067ef2d3d686 GIT binary patch literal 8248 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 Z$^EzW>vBm43fS>hMnFcC-Cfs;{{wDIx2XUC literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/b422.jpg b/tests/fixtures/codecs/jpeg/b422.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0624bc3a5a60a77f2afdfd6022673c785400b22f GIT binary patch literal 2630 zcmbW1c{JPU8pnT;2(_=Vw5o(uDQc@-E=q-~hK{|crFK$F8U{&Csl6&1YqdwiD6QI; z+QOi*VBnNN^gTTTd zRv#eC&dCY-F5oYLIKb?XT-+ykc-ak2LI4NodwNbz2!!38z&-~c!ki*<8m3TDdv7lJ z2rI z*ne;dv$;4R5HN)68yAQJ%idsN2&bF|RK(Pt%R53;UNezf%q*w0uIB_?%Yh;86Zwt@ zrl3t%-28_2o$S8@`}zMO`zP4HxF!KUFo=D5U||3WFbcY4@neFcFZvk=#|1dzkz+|f z@oK!9eP3L#M+SZ8=)#fmf|nq9C1u5n5a2qy|G47Qsmsmf6Mxw({?AH{vg^uVW%+<8@`?v2<@15aEK{ZF_gmE~U37%Sao!ewK>` zhUs zTRRKjZq9)SYVT0(Ez@0R79AbI1k~9?uk4ReK_5xy=%P>a)=joNn>(``hGKG}UOm?B zSR<@XE$2H(dNcH|llpP83Jfl0k`W8|NU8QF?fUG0Q4MXHK`dfNCQ940W@(s9{37osrOa`&p*u2ctk!3K^AM) z?47#K0zNMwzm~;+4q^ea3_Q)^81os)i(IG>Qg$^! z6#vqR1whD%1jBL`FyN&AdQW=!+13URdEu(_aToFk!L^Mr+|Bs?Fx7-}Gmz>%O0GMr z8`Zz`TAHYzt-9@Z3bZAHGU7X(B>EElB$(#p)--L9&~pbh&onE(bUET$)K02$ck-a5 z{)*SQr_AE6QBh1)%znCnL#DI)kg@||2VEb;Oi=fa^3}W+x=<<^TW~l@oPfZ| z#c2LYr8&0Is;Tcj$$2;y5E9>a{lI%uKG*1`rJw@1?%D2AuXIV)+m!Q|69|e9zX`Uf z2{w9{cuViC%Iys3M2!TqGxL{d(omrt}s@CFO$TVdC#~X zdko%eNp6%C3-nZ>G^K_$#-$w4iY@;gQ;FAjq7aZA&-dGj|hzSh-KN&7Yx?G)_TG3cv;mqgd;phs$rqcu${ z@*RbcoPOrXyR*;VWc&<=D?a!Tpx3i(YS@gFHjxUJaE4Kjm9h{muZv~+pEEQUYEKym ztj-bR)l)i*3vR@m`>+|k7i|5UfO_Q|EQF?qh2rGWhBb6Tl+1Lo5i{ZWTJB6*9ph7f zW6la~Ux%6#77Kssw0Sdzdu#+ckkt(joTyXlUbdS=b*nZvoS*klx9iff33*}>T4hvN zYS>}f-doG(3pJI$ByLtH-a#i!!;aMQYNJW6+nThMIPx~~~2uscWW@xuU=c5a_uOPub> z;5`qbVaTCJa9PvT4Dn^kZ|JzZqu98qD|QEIhc@mWYsYeG>dF0-<{Zp?$ZwITwd40k zO>m*MI4u?KBCBjeanu>B>UWEg%fhzd3sNX{@2`hmZ+89OyD8U8ho{huav zjfB)_%JR8;dIre{=2<57z;8$namQ*z|*GB0alWtNYhsbJ<8TZ#x zBDL@A_~K^z*3#Ik@^avuxmCJQ$BjJuIq(&GJG-ZHbHlLc#v zmw%A*ojaqtweJ7MDsrtCe!u6T4*H9&nJnaNX7o#kVXyHd!8lxL;iB2Wtps}JI%l>* zGC2KXF3~{Nh1@x?)H0bger9I9bHc>komhP>w#jwqImwn{H*5cZ{AJmOp#DilwPEI$ zKXi3ec#YM)MzyU-#IL{kOwRkKmC0KrX$(wTU9j<2Ds$;swyn=h g+G5-=D$lj^TbGpF59+cFoaay>adV_wzq8)|1N3m)`v3p{ literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/b422.ppm b/tests/fixtures/codecs/jpeg/b422.ppm new file mode 100644 index 0000000000000000000000000000000000000000..37088094fc44a8e1d0133eeea9c8e689230aa8d1 GIT binary patch literal 8248 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 PnH#P=vfaDLuJr!^9;LO- literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/b440.jpg b/tests/fixtures/codecs/jpeg/b440.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e7294bbdb6989a095226222d11a31d3946665383 GIT binary patch literal 2744 zcmbV~cR1Va8pnUJ_oxa{<88%$Q9EYes)}f7t)M97Md=%-WKRIQ?_R;XFE ztMm|Ctu$6Ci4i+F={wH3uJhM9=lfjG{m=7#?(6%x?wdA2n+NzzjSF)p&Kl7=xDi>J(7EGjN}Ra#bEQ(K3tZ+O@E zp`){_yQjDB<1l_?bZmTLa%zF_mAJUHyt4X@ytTcvOWE5$IQ+o{0vP|qqSrsc{)3C3 z&c(pQ#K^?@gA2qEOuvl$Ow4ChSWaEEV7=ula8C6;+iAn}{Hk_#Ni|E7psU{y2Nc`}mGaRKne8vd#Qg z*mLma?JFD6#7MBf?^Rbq`ZqiuTqYe+pG0NttQ!aq^)rjaCCc2>BQEb&-tY4LuH9;9 zZPxl}?{4e4>Cil_zpZ=6=cbJK^zd``mqp|}gP+=1^B|zP%n?-Gq_x87Y4SfC%)o_cX?NZPcB>^R|QeyRJz}Hdo#GCWwTK$~3BZ=TR!l!n$ zY4koE4)tzyKnNz4FPWl_NeSWBcmCtaAL^PRCAV={!lJsljGzGS%gx23Z)RQi^nZv@yL>r+=)R zV2Rl>aJv>ir+kS`*8i?7heDuI{mL%Op>7p!mhQd_T|rRL&p-by+TowtGzje$LE6%45Hh z!^y+rExW^G;S|sNqHTgocPt+_wKeYS;>~iG$2IfFG=TLazT&Rk;`^kl|`_xXALTa{na?9IYLyDuy8(CL~Jz2yxu2YvH zLyKrYFH*VZKxBci-$L5HN)9Z}imXHk5__Q-<+ooncRhY}MOvEtZ5#0;IP zshey+@80JE3lJM^lc&ZNncEb}S~(6X4Jh7-%=7#fs!p;?s($2!&-9(`YYL+nh&JFd z^mS-}apSOJB{Yy@R*4rR68e6UzkvyL1}rrp#(so=G2=!PYq3Hm`@5_i4q_^(fTrj6 zK5q>ACFQ)v7zSI)<-#Vi3Wt^rkbqQ2f5mJHr~vO@W>uFN}99|RWl3@`8_z^MYx+Q z#wbBPPE{eaL#jcsJh-rK?pTWA?-ZK0?>e=$jSw)ZR+nZM1qO}xK2QE5rZWw$eNZp2 zvGDsN;>;+kmoprUub0ZCJd;6t?*{pdr{_r2QJNc%B$5vOrf2|nTVf4WnqoVX8nbjp z7oLkU(87&)xKP1%dXKAr`Gho#ReQnJgxK2mvbP1|VTYJDe>dim1dl}Nwh3R=$R+U@ z9kVUOqx3qR}vy@G}5g~gwjWhyUZircW@XB z8s*0gA&aY-1x+?Ek1jE zA9ZY&N7kxtUC$lL4!<&B-eXwP{BUF7tTX4SkI%x@_$kHrHf@4c@-1pzOp>k*s^y)O zzPdCYOU68wx4(0kc7GE+qNdmD?DM%<1^d2=nD)Zgo}kc;5y^I!(=fO6GVS~P)ERC@ zT~+qG(G!RgQcurW>&_L2EltH@Gpqg3PV+P%C_B||?d3-Qp3n!vw`r3`vc}RoC?)zg z>Qs7ylm64JSTiUbn^c$vWnD&tYtgEhbK)}Q(oy{%1AAz_yDUFk`_6Sv3Oj81YPgKP<+Dot&k+bQfdcuEg!vov2_Q5H zV@(58vc7ma{_;%Dlh#Z`O?~cd^*LUR4**)}y8~5v5w2w#EIq$i?wIS#0!BB@~S^we{(IqMXGpv+_TA(Hu+E0s}-04 literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/b440.ppm b/tests/fixtures/codecs/jpeg/b440.ppm new file mode 100644 index 0000000000000000000000000000000000000000..edb57f279b96509057d29f10c3777c467e458fed GIT binary patch literal 8248 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 tM}g%&4PW-FkTE-7fXn literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/b444.ppm b/tests/fixtures/codecs/jpeg/b444.ppm new file mode 100644 index 0000000000000000000000000000000000000000..2d0ce918d258fbe616c8415416af257bdd4ffb30 GIT binary patch literal 8248 zcmeI0_g53xw#QFGFX_D#Na)gpgl1O=*g!;tfC^Srf;bjt90}^&nX!$7WoEpVQBfF2 z>`1YIQbO-YO9<&b5ELtD9`~2K)_d#z0q=*q*ZJYB{lhumv(IPmeb!0fICFyCLc^Rx z!or*Z_zD5j_F&2xVnKijEHDxwY6?W=4#X_Tpf|L~AJP#DX%7d@(V%WV^!YOIECy1s z9P(f_q--tZPAVwLfLz-IxwIYpa|bxL8*(}ia`FK9`FrrA5F$JR$v+PAPl9jGKyuE3 z9T&llt6=kWkZ}{b{x(P{gCsnJ#FvBEr;ueeU~wIY7C|`eU~VS}=!19J0`pNkp0{NDUpWV4=o5QA0lH-XK(0 z7^))@**YK9un6^nhkPE7s#=A9l!U&w9(6YZb$b))#%A=D9mq?&P!|N~GyBk|zeSxW zK>d6Kb>tZOyOYT8P9ygfp#;C7c3wheUqf!aiQ0Gzoq89MdLOywF=|B>D((d`rVhDO zgqq)k;&vfIdr?6HXkRg!Ekm)@C^sF7WI*F4kf=8(#7C6V7nH3P1%60J}4k)gI~5GM`nyfL#;Idd_24u3|q-WS6C|%hK7U z8`;+~JuhdoF70HU7qEZ%hJEr|*6{+?k4IR-W9)BFdgPyG@B5XV^BXJs5^Kjb*5;e6 zj9cvWWgaQ_*olu=@f9rIGuE9%i$oY!4NSp&IF!gByrUgu8heUWpf9;x!rTP9U+{ya8C0) zPTc}-O$_H*ET>{Q_dx=;ESYnM&nex&y}l{@(hknWY|gnH?&-bU;|DoEALjg6$Spj| z%|8*Ae~R6jxlqQ77pwk*Woh<`jrcyJgW_F+9B?pYuqH7XCd&+ zlsGjtPUgXrvg3z+{PM~;-g6$Wj<=+N7u^&e-o*>+<^}b~`3}cY5B1peLRw6awGUmN&0Hu0})OZ#Vb`uW}Ir}OwH4)A|Il=crHUs#x) zf1ICxlK;(_^qlkQ*%$dcuJX5B=VuhBufLO)a+ja*kRM;c=RM;utK~1LPm30%hjpff zb@PMz_&!5?_GlVQp5~_ElXZNonU9?0!{76rrulYX(;z_b6_WeeHutSl?gTlMZxx~f~*_4>BYGz ze+$;#5v;zS8&{qiQ!Q9pD_B&Q8`ZEUv^{5TXKr9muJ=GLOCs=)3+U=xqIM6~C_qi* z!l!Z_Kjqra2mn-QwJn%-6uyHACou&UywF4ys%b(Qt647a;8B2sh35r@zkDM+nJ+wEQ1IgsVd1gD zZ%-EFpBC;bDimB0?zkk(zE-fgSeQ{#n0lum<-RcSapCgHg4h?rn3n~M8w;YF3pt$y zVLb&wuZ6xNLQh!%TPbAfg%pDjHzCBlDL{NEaGEKwvlc+1=d5<;J~^F#3qNPUp0kk8 znW*Q~jPr7Kk;L=Y5#OSLz@pyJqV}k>O$&y+!3`_q#*A(8JEt3O5Z5NK*UZH0TJjAU>(-d(Es5W) zp}^wa(3|ZMH$@AI>lYTkjQjKD%0D|-Uu#Re^&q+AN_xrd%;Lvc#kaC~ZHe|`UN*AM)0W83ADgc~Jm{<@j*_l?v`SGV829aD8Z zx$$;PU1>;dad^WGZqqfN_UjRyHv@W$g9mSUkCw0%CGMKP;kv&Zb+_Qg5*JH}!@Clj zkGFtbjiV;SogjqSnuITfv=nAZ8;Z)Q|Jb4lM;k3)tl-6WOtv2tH|1xfLkZGJ+ul;hr&Bd5!qtxp_5ixsqdg|vROZ=G^!euHct z$2IHlEi(5uDZ6#lr)?;ptv9T#J+e(SueEMb>&vB$uVPys#y3A+Eqc7Bxg@pa`i7Q2 zH?|e+srqqu^M!+rmv+?`9j^cB_g6;>T7`$&e>%}{{B+y4q87oq#)6A2+x~1zD{kF* zvwclTd(wm6l(Oc;%C2SAEz24^xsCNf-J;;WHs67E#z;e?RK!v=5w%TpW1GFXm1t># zO*J`Bi|nl;U~K}>5v#5Ev!i4RCbnQC7NXcp6Kfd~1#3|3IW*!sG!Qt{6FS@$IovdF zxPIYC-O{laF|vE{lB&ef2dRo*H%b58JXpSY_{s*!*`4Bx+ob1n#(p{`6&5Ij-^dGo z>^l6Dq~Q3d;PlAe3nP0jOVf%a{E~s}lK$<*{h7BV5l@D)o)0g2)|n_8N_g>lQIjsB zc_gxJ)Td7zAePYO!*tDnw@FNy7-1VFD6<&$R_ydqY&RnYw#I2Y(|bp=1!kT=nZ|Ku z6Va@tOej6gBVOhKpYgsxb5F>42WPxFazYd}QMY*V>0)zLtg(8P>Ha!X8DCw$K~t4E zd34L$n_ErSc9?!UVmg&)I=ap9!)e{|QP7M`^>ex`1fwJgb6nlw|HY%NK(7Hza%&$6D~GJW>&`_lsJiLKV3k9|0M-1_4& zYtrd2N6yR~K4;zXyLHF!pTECo-EhUqE4FUGZ(US66LZJPsj#l7wMM;ovv9yVzxLDI z*I$^!A0x+Ryyfr1P~~LN(8nxphL1Sub2WLHoJdzth#H2ghQgE+Jf!YG&ES}vOal~)if%R`O&>8j zBi7vJIrCZKDmBw(6F{a3kQtD24N+#qs4M{nMa_ili&AS)Yjj$T!k`{AsYhp}{zoH` zHUDu?HAJG0%urJ)DiX;^rmJvN6@zGylhty9&P3H{h#G~v+DO!n;S4$hk)$P&loX1A zMAs0>Dmq0^z-x(aN}57V)@X?aHASwVnhgYnnyS^R=^7o$prXt4ShI?vQPDIyqE5rm zsMK1WQuDvcibm0p z-Q;g*N()7+A!~>H*8h4f+O^}mV26B*sKsGWlqYUK~Y(gBU zRbzBA^4s?~vw<|AQhG|YRF#G~u4J3!Y=s&v*OS!-vaWwZXH;mF3YFaSQK`@=yNwzH zj^;*UVBFo zJ@nLJDaJU)9Da|`Yw#K~Lp4So*P5`ObPS0eFV{kJ2DU*BlWLsI6aFTXN^DT7^`-%x zX=GeEtW-}ZC)l_UG8yTLVZ&fJ54T_z4MWDmScG6YLyto!F$^Wcdjf@!P%vLzXpI=M z#@zsSGvde^3{~p~*Wl@5hKJgppj06Z5{9OS{CNVQ3ZWaNz(UI2lQ?_14$#*5tSahOHW7j_NTMsgHVa z5*Mstk)?R1f$66vP-Nb|BXBz<1EqB99mJ2l!@i%uj%#UVB~?F$8P^yYv(FUiFnn^{ z>$TDKlOj}SV42hujb>b9(2uEPDy2@MAJQ7+GVP$Z+Z>py1H%K0BVgeeR}$XK%acjM z&^+CB1hSaQkWneaG}D^0=!3Dc*Ul=l|M&;0 zL5kL^ymexLR@Cq{3f}3lh(-bJ3hG{V2r}TsoJ=vlqjH120F-@Ngz_) z-IxfP8=2~Wq%&Ytu_Hr2yA_tE!cs;N9x5tYO{dPVO*pumIA@g1*5XjFNseY`nug+| z7(tlF8Il3`sM38*?jcjbRSKe6KTL7adAW-j_;EB^PV*Auy@oyDCOT4w`Jkp-+uZxa z)H);K-4w35&&~K&LDU#Ly2r_KIpU4P%QOiW>yff453}msh)z5yF^;H)RkBY*D#es( zy2iKVmP^N2dN)9U;6>OVf5ab-Plh62U$kR5zyU)Rv3KlK~io|YFK<(?;S{MM%2mm7k z9sgDDoSriF{m^yLg~7mwyJj0mO0Y4l?=SVM)nqg(qDMj#?B_-}C2zHvJ}eT=?;K2Nc5neJ z5eC+vzyB`<~8u}acsx_(a7V3pF z#Fj#~cfn!rd9@WIUR;5;!$~f)p$-ahzToi8xUEmNx)Xsz(U^ekXV>IYa|PF9%5U40 z3%DHTxr;%uZQn&?Z%t60KLwS%6^caLopY?W=JoY2eF;NR!xjK1TgSF#t)IW^dbeYE z*#d7EJ*mvEaVHNEB9e6DiI5&e=TxER3`dUgrEJx4mU)_4|G8 zfeXNrI0$z!_zes-MD;ylJ_P{2A{F4tHXTbFwOcyH(S!6*n~?cn{wjyDP1Pl+(czd@ zI1$WYgZM0L+k%G9*q({)eH#xz0)xSlm5y~$k2~X9R4IeOk+jGKc2P^PZ}K`N>&L8n zWW|dz z)Npz(NIV9dsqig7fS2s1!3DkVkJTh>1t<*g3kK3f1GRpGm$BVJ{`PA!>A()!wY;%r zY3uKx+LHyAEJuee1UF|%IM^|{v2Ohd07K(lncxwSPHpeHOKNh0J4Z!0W#!s^&F(3q zRNbI-ZQ2RAF_6e~a1AkZ!M1H8UBnKth1h`PBS4$frB7(Df%hfkIsPkO@@zy=vd3(3 zUqbhWgMdi_u5ch;(DTgw(RJq@xTpPHAgXh3f8i!)gn`&B2;0r3BT90Q*;p0y5;!>H z+<~(V5NC>dVyf>rS4BipcH{ylq|xRhAuK3#JS!k~%PTotvWP)^R?}J9)?#P{B zNhVmB1ZfBveH7Gt(V-vU01Sm(yWaM;d;b%fycF8X&jy(SJI)$V?cVd)v$d72nzO{t zh6IQUK!f{`bzke3gXQyLfEyFKB@a}wdMmi?MWBh`hxT9MGIt@UL=JZ?YWoLhs`Iah z+RaAT#vV$#32QH*bU$XbMJyo2uE54_0AooV$_&M){5GGtz{Ara{RpzmQ7lV+DM@Ix zgMzg?XK}?0t`sTr`ldFSTrePf2?$&4tleB~_@+^}O|)PYSico4Npe+Zyeg%L{;+Mu z;6XruD-;c8wzYPx8L3~`xoj0kUP}pH3jP4yx*bjO&7Dz8&|&idCmsA{GiuJ1)C4rl zR$~;yK5@Iv1Bza~?bS@7w1?Zm2uE@w9Jt9qpL1t)P0v_jEyNzc(SQ_yP_1Zu>et(| zcm&u3M?1h`xsI)Q(7$%Vz;B`iL!%<0;at!XF?hwM-um4$0tIY62zKqa`wcSK6;b;s zXJF&Ez>fn6zW6H2gAe;V9#VQkmjQbmSQO#Oi+FLr1R2mp*AuyOtm7b4Ra56 zT$KdA9({R_QZHWD=jjQe7Q1=}LyK`Of8*p236HZ5*+fTy*}kpL6Is6#HP0KMAmMnD zEx#AB zEljqLJz!fydeTT8u5hdM4FDtM~1pxP(c zF+Cr>W;ZbIe*N}P{X=&N#u4ho0CSex8IxXG^Ca^0rpN>kFTgWnv3()WuR17ng1*@r zwKE?Cr`R?y#D5a%?~|WLW`Py!?eVTq8gS^392if)eXTtn>062iZ0((27+pI^& z7Oep5_J9S!&u#fJ_I_sr&~|tLyXxHA?mzVDKws8&Cn^8gyTW11{wi98Bbo?S z!trlMwWf@2AkQu_{&Cp!Kp#Nr-$i_2;OLy zwFk7Yb>-e&)`Oy@$tZUwY*_|)>>1w2?0Tx$+!~)sXR;99bHEcnkv6lx*tv;} zcL_}gK5pQqYyDMF(;Kft`ho0UQOQ~0>#_bAsuM9i^fu0OOP!|nE)RM;^RSgNSA7@=pnNQPyosUP|+A;&hY5cmpws4{yre< z1n`drm*{n$HjC8jns@$ycXR-L(ZHBJVA|IBWncSshbFckz@nT{Nbu!&@8F`L4+qO> z0U#yE$5s;8>kXlNRPFazK1qlJ^?hud=MI~iHx*L`Sq+t=H!6l@YTDn70 zdWna>-+Ax<_nkBM%-lQkefQ3pnRDiD`fdq8p{=f^4#2_!{1|H&LsU#$IqxCoJ-yx=PoEFfwRK~3(n=~; zULBJ9zVAOmzjb!q%>u}9vF=O6p~M9M6aa{3jX;(xlD{=Up(QABumfoNcF#50g^$lyzW+CXOsG2%L0?X@jRjqP zbOK7eKF~PJHayil2{sc?k50I;b@xB@GzUs;9L%*s=53GcFU-D?7nbHE(cBJQhlc9n zXRb{dPn_IVa@f@#-T|g?PueO47IH(~c&@sy1NFn-7QZw8Zc*saayxYgXw`nrffSB< za<6RV_T$U(8m6i|{6^%m@%)r;m4$7g881XS`wmdIqw-3|ejI1Co!Ot~%J@9g=pl#B zGuN9NX1()YJ5U8V_5;j|tQOrTXINWHCgn-<;>XV_1=UmEp)prH5ev$Q-%p}SZh{|! zw}PwRWs4*nFA2Ph_E%{7wrjDuX&&?Q9@gtqiaUS;jz95&>C&I3@y6Z!TQ}yK*MtrI{mpCj zAhvg-Jd)*@d80p7FHWicFon!STjQ#6K;CrF=r#r?u1{1ndU@?S6+5LP`8eW4jMG+a zArJ<^?l1s=O6w1ScQ4g$LHDN1ODf$JaOim0?z6sKHzMsWp^qDP0EyGR{LpCxzIS7D z%Gm?MNoy~==gEil%wLYQ`dB=YC=}Hw4I&|Wl+^Q(Kx!@z3IJ8F7UvQ` z$|fNQ@HDYYtGqcB*f68#SykfTxU8O_#jLHt zD&gK#AzB*5iRh^@L2mtccbQyIUe{$7i5tKW#qOrco>7H>@u0^e@_noLPvs{CAjJn- z`uf~{Y7bP!G|>hvuBv`^v#>!AG8(ENoUQ<)=L65{HB0gkV*?!a#EG4Q9z@c_YncG8 zzBAH8%=1~wk#ri;Ui@Fj)akP&2foXuRRMk?i#gWb3?>hnWox?ip8c-(ySxKD);+3! z1)mTy_JTSt>$n9Fs+z^)8-Ky!3=<1VAm~06@>oA@vqO^zJnmPz$z)jxbhVF5EtrDD z5#AJ7&OTWk6|xAdKU(!jOzfe$G5=0?Xx`RU7NA>uut#@m@c4IotgfK_PN0>-nVh!t zdW9G&!_V+j9Ym=c=VvBW-x&e}|1M~s9kU}N#|=x)b>!llc|+5N|I+07 z6_@V5MYMcArbgi}`Klfp_(fj>(fI$U^RoRkkc8ewN)X;%Dz%eBv z;uhy;gX#uee&( zo;l{b!ZDAlPtMSd0hi8me9V6{apDYIe+WLkD3}V&p83-fm@HGV&R}M!-{^0?)Pf6E zq8?!76aajIK87eu7^prNmFvCq$)oN@S2s^eCB3X)cv`iZo#)zvc#8KB8s;<4#`(2p zRLQnS%~gxUX7wlALbdQSN;%b8$3NnbX{69W(OP77%A#+K06psq9j;ha73ve@K35na z#_UmSXkppI$fDAAIC}I%Yj?iZy+dAR;pY?gzGEhzl<4#G**JR~gNo`_%`|TA=<@9{ zu_>B5e5c671hOw_y-LZ-9&1rCw!SaZIMKn4C^x-iuxOD5igt>Vi!1FZF>Oj-(14c) z&UN|?sK+Rh-wW+SYq0xfUf)y$?)K<&vSB1{m}o<|JnVU(`I7N!L$lZ5#j$LLbr&llTn_z@XgecZnwu`^2N6^l@AWV8eR;Nt;+Vq zt#wdSBOjE(6m(lh9Jo1am|>HJ=i*%Ky+#=+hI`Xx4>O-;#VDyr&iizq-Un&#wQ|d%bna5X}E!vP54_!LfXW?F#JI(oG8Ds;?wwRw?op@yFy$;rXb*4f*$=E*r zMg7?@4iY~q*OUSlwTIv@9+<#F`OUVHzo|EOZ`U6;TiFHI)_f2QvJOUL34aufUm}g=K8@;Dh??m@y_gk#8o(mJ$acNfq6hgPiMW~-gJTxjeN-I z(TYf( zi*&;%!)?Y<)LH4*0hbp6eGe&~r`A+q#CXliYCQXlQk%+WwDg(M-GUW`q8U?ytvD%x z=!wCGb(naWTVzUJ-JCtYP-Ubp1w_PS44&2q^iLt0oA-D9tDzvmIVWE0H}~jsdkKeS z`?RxO*3=4QHB);;{n%*`HSY41n>5&}r6dL`Ap(tBfKC-)$&h}FUhd?*8EYV;NZ0Zo zgu4{!%9;NKZUmq_)YUlHdN_Rxrcxr9^YvRBlg3{xa|PKIypv)PzKUc|r-V8B z9HZY9@s}5LlRvJTYZ&)*GI&ptIzOozkLFhc> zVHK*2SK87#f96kW%e=as4Ec~*!TGroD@~Ipe1Rv(2*@^|i?33nbpQBK5#E3W+`bc1 zy>hMl;W8%68BQQypxiEQ=>@qdZ<@A_*X<7-7p1A^WS|4(t`KI(Z8ca`Q4Olee2Id= z*bmf_Pm9-yG{gV6#fgcH#gf_bGBz)c#>FGy>@5BK$(@Qyj6f;Kyax9gcHzWQh=TPd zb6axHmo`O=DR$1*(jSN1B;BZfMx8)GCT0=zL&JI}cn4~~Ml}DDl0zK?^i^~edH~m#W$d$pZ{p3;AF68>cyj_2>Fb%a?EqKgj4We zwN^mW6AvjO{jvR$dl$u4=XiM~!y>nerUqhdE1IU9U)DO%O$b2-Xv`oM5 z(1jft&9ZBK81R5BGWbqZo9&hXnI;YMlBL5i#16>lG;R^p9w0)sI0w!Nc17W0gw&kQdA?84&Ab2%V#S3mDc%F(C5S-F=rca5o_n1?~4@<5`PrG8>bUf z3Zd*Uw$oHMP_^Jv;El`e6id$O{mWF&RpN$xk)8QAmE+T8ok5|{AopurJjGzul|HaW z&w>MSRB2(+sAOerEYN%85<@%?T0UoNTVL`9eRsq@f7daH=f!IDM$Sus07{w`-<)k2-oh#4i< zz9S9CHIo=O-Mx+JC;X3&H$}3AX0MP=?gEv~ctabEXfpZvXMDk8EWYt(*U!$j%xE=M z*tGGj8<4~j1EAO-z8)<9GgUpx6`0R0bo|k358gq%6cUo5HOpsM6ZciPm_NltD#5SJ zh}Ns6zPB*D@K5%SJwe(e-v^b8{!^$x{z~~th~9MQ_nqz%u#Za>O3jyI5)zCJ>KbOpZ}s%@PLk{RfXu(C+vhfFwqR$yId?+oW5=oaM<0H}hk_#&uFDV;60gfv&3iuRG=CcJqHHZ%THg@WdPdd>P z+gb5#R9-|qHB&?r<=u!Y831ShwkMU<=8XwNBTQSEPX12DV+vTLLe$zD7|KhM>~3az z2j09INSU!EO}*j}$_V9I<{%a1lGyn(mf3hYK6xzDC#XAi;~^TTD8HL%VP@cW2T+<9 zq|5(g>*-Q&NR6!iV7oOGy@XvILo9tnINJSIk~otHqV?QoaNCum_*5g(d6U)6qb}VL zrBh#5*J=#SFO3Jc{7jD>s{tLnHXN=s(Ebd=hQXbr_1)`7%ue_0qRW&gXC3YjM)P~4 zH2DF<*CPOmir;??I^8rT$zA(pnNTohVsVH{ z%%iCFa=v$`V=vj0U@#qt+EaRiE;-K?ZR95+op@E*kA$5tejk)SVvpLk;Wd0{th8AJ zRc1+xNN|lke}h8FgPYOxYNyup06h6B$H|Oyl2X|W^nr(Tm@R!s)SAo4whNC9wb+jH cP*!ZpdhtHUoN^VA(UMN`6v~hhM|U^#KgGJ;Q2+n{ literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/gray.jpg b/tests/fixtures/codecs/jpeg/gray.jpg new file mode 100644 index 0000000000000000000000000000000000000000..86533a0fc0614a44475a268b0a5a24ea112f2c82 GIT binary patch literal 1562 zcmV+#2Icwx*#F=F5K2Z#MgRc;000310RRC1+W5_|G)qX2mmbr zJplm`0RO}Q9{>OW1pxs80RaI300000000010s{mE1_uZU3Jd?l0JRVR0s#X90t5pE z1q1{D00Dgg0s{a95d{(Xb($mz{*4NnC+Tr5kuh6|e{y*)%>#F|%FmrZC@kl{{Zp-0B!#OU03;v_kVzY@>aAj`)~gMq9m`hbRYQ&!T$gP{{YZU zb=CM7-wHfhy3Mwg{fRlhxQFc##H^<=WrqBNfCk1Slfc0|5Kl>G;eA^E%U!#NPq=Gs z4~;@rLaPbf%eS0vA(4R#k_w#kudy5BAA>ZTTP;@WUbjmbCMvQjyOK~y&+@94`9w13 zjtb!NKs^tL{wnxmT(P|H<&L2w`rfIgTuEnUEhi5u>~Xkd005O>2_rjO8NsicbgQ`K zxYp+aM2Ewd0zFnqB4k@q9hBs-85xbnS0f|bSE>9Z_@m)(33#K!9xK(gh-~x=sV*Uk z@s*e}h~+{yfLMIM^&JL!b6;57{?We=G(Q(uX;<3xkYC(JC5j*H`=;Km%^F~ch{3GM4Nk{Gv(zBI zu#N@rV-{4?8Qq859@zPauI&;P8&?8UQh#_dmzt=%y0p?RyiIxHX|8NO-Twdy46Idj z*Jf4_w6LB;YNU`Q2ltJ&6fgso8myikv$URQG~Wre)Lo(4|R1DrJ4x59P-McIf z;5&2J-1vJ%@bAZ~Uxv0iV%X@Hc5_}_{f<{c*9&fL7E~@>;~=12f&9MvI)<;PczLxC z_)o0ny7R649ch1kqKV;29^BhYB86!P-zI*|84S!wBc0i8*m~ECu5`F8JVP`|ajI(9 zPh&Le^5q!FL$WsL+E6^T^EPfF2_&<#8yeivSa`}W21gS&h3zDDhQdi%voJ}WCvtko zrWGKlUP;bW?W?eB?*1kChFH!n`~zmuX|p7Xp_U;efVauHpD@O9?Bgr*D+YCHM_$w| zyb&Labh%Sa@lLF^@?Yv|8Kj;zlW&*zhB8^6ac;jx6^e#vD;#nEiNcxDrs(jqGqKP?jWMFy=;Pj3$keLsW-Kp+)zLiO~D0a zM>DOo{aW49RMe*RoS9qK(tB#=%)c-%EzW8FgE?nDKR@4x=kW4EK<|n|!XnYTP-yfn zZ>WzC40hy*pML-xel#%X*sQr3(>CFM^EA8`h#XM=h!cMAu3u~<@Ea_(GdS$Rc8<##<5%mI78@jPB0s4pxO zfPT>rd{uSz`I_3gx?e8TH#FGsFEwBchzp9o(0cC&R6>$9n>fzy$5v{%ETh7;>Hfe`c+R-7Gc66(HdXzoA zAZy>CW<;YN0WZdMdV|qqG@8s7Fu$d>t*zZ&W6$a8R`sfSRDDCenxQKLnxVmA?I^f0 zvti6+Fiu;?$HynGPF}k-@SM5{{08P&Z*U!!Ql}ts2|gTH71M6WSy|frzR(7XD6p- zu3w+Ib?esc+rK_|aQDgG#fJ|cK7KL}ZeiisqQPi1Tddz}rlxORzj5pK%*^ba`!jd$ z&)$3dXm0Mer@uXVJiqW{eqrVDv&H4rwdZSVYcF2DeD!L2+FpO-rd@vL&fU9U&cnF} z59jBeK3aS_|8j2W*^+H}$@XGp<@uY}E9);`y?*=V&D+1dd-v}B`}dyThWt8|LZRrA z$*zp)Ejr7XX^cjtP$(o4tFTxs5f@3G*=#GeW!sD2H#asmHaGw47^zUmm2!o`Xf%LN z!)UOd0^rLe{xZq(ip_p*v)_XI|1t7^<_q)i^n`eNLXn8bh|t&&lv38!(JfOL%sP|B zGHRxi$aHcR84#CHl|VdMR$%|A8{`+2*0K-}EIqEUgUFhrQFTdwF< z$iNp?XVP99%cfB>XiPFqBoq`2CB-Yx=U0~&m;bu?@$LA90Te3XMeu zN28UU3T20M0Q_Z+>&;dJoyf`t2mo1JCXwWq6fZ8mp0}+o%x`}D_~*y<4~Ko+;ht`X zy$~og0udP+BJb&vEBZRD#&M%z!ZJi;WHN|!GT|J*4Ez%c_Hg$>91laFkdfhCGI>vDmtxXn8MRKBwPYqhq7eyzNL(N+5egQT zmzUSp7G7^`e%k!}_fK3(%TKY0v$aXbb~;t|;yqJ&4MP1s5`>5=0G#7mihgm}aY#|d zk3&L-S~w?8F+1{1dxJ7a6}Z#s3F^X@%kiO9bA{9qd)6|LACR!E93XDXcA-~kc7~lC z(r6*!{zE3f#q&_rMfUb!_$7lZG9e{Jr(^*B#Tji$dk!BEreY5M9GE)X>g){_5!HgA zNCIBqL)nYf)$BjvP@~hPdIiuGbyKsrf~yxR=vLmB#YI^p#`^J z$xNhYb~O^S0@F<;A|8HUCZMCZ6V1|sDCh0^<_qj_x|+&?x<&KKGx@NHv?0j^B046e zlIB2mscUTvh>26CH$c3ytDDq}u+ufAvXCg0zC|zai5VLuxP&?K(psr(S9vp;D%i&< zE4DCQ;Po6z0N%0oe41}!WQMt~V7FhAoaPdqtLBml&}kXzEkOi~PFNZPM`vRBY<}2&1aDd& z<<2k2OASV$DCJo8F1S;?h!G!2xZG(CfRz#yZI1ZdiyEbC6uMWX#!ym}0CtD(p1!6g zObYr;kK*KsGwCW|4+KZ=Hq{11C8`>w+YZ2#+?s7p?y~kySS+$8#c+tn#Z_r|2pC11 zdunft8LLABSbl%4gG020OFHTcq~U2lTidiSc;MBh{7~p_{4kU6<$WFya`?pNQ9~4d zM|)joqVG?7a!C+0b&}Z%iw&k`GI$Xln(=eH5A21fv)Lz^8RF9F0Qe5BH3OZKXotKpE0Vmu3$rm z(h*g%FSJ6Acgys|CRf69*^{g+rx=`=Q;~qh4P4Fwjztvr(w$+hL-j?$!f@I^OObO# z|F9klaosg}K?lzX0yJa0F(+wa+CkWPNW%&7 LP|-1r5T@YYWX-=X literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/p420.jpg b/tests/fixtures/codecs/jpeg/p420.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cd78ae91398b194888c52360eb18e6939fc75b82 GIT binary patch literal 1992 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 E0d+*RNdN!< literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/pgray.jpg b/tests/fixtures/codecs/jpeg/pgray.jpg new file mode 100644 index 0000000000000000000000000000000000000000..06b705b4907d980bb7bdc736f498de0cdd8cb299 GIT binary patch literal 1477 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 LP|-1r5T@YYWX-=X literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/r420.jpg b/tests/fixtures/codecs/jpeg/r420.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d831c18d41b7507e8e304744ab374da4d503ee5d GIT binary patch literal 2395 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 W_rlQ1OAX|f9?r%c=4@OLd;Cw2GFW~9 literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/r420.ppm b/tests/fixtures/codecs/jpeg/r420.ppm new file mode 100644 index 0000000000000000000000000000000000000000..86af7fd9272b469315011faf621e44ff604c176d GIT binary patch literal 8248 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 G>i+{X&9$@u literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/r444.jpg b/tests/fixtures/codecs/jpeg/r444.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cebd15139e8c4c5943153a3a17ebf8e388db667a GIT binary patch literal 3236 zcmb7lcTg-Lj1k4KM`s0JZN9(g905+rqpQQ3rekpbVLDfqxevhhahg8sN>gRN? zQNqF>#{6VvFK>v(CVk00D02Har$|tG9e~C>B zg}&yjrcQp4RHJL=7ZzSvJ2+(F;_IJM&71)s0F*fiz*#^?r?4OZ9iY$D_wMjg5IIk+ zY56Bz8AlJIIK_!&Z~rkGP#Fw6dz5&lEtaq&x@vrA1rT9i*z@k*}{aS^l?y+YoSbrMk#*EILw$1PuE3|)SnHAf&(|az=!TRzq zS2R^hy3G^_?Ht2?jIN$T*`g9_kM!gs*>=#yWI{XOW0LsR@!5hF*s|ocR9>~f$z%_P zd4%xD%O2F1vNG1CWD_SgczwUS9G+@z&zVwW$~ON%p*A|ja?gKceQco{Zw@cTOM@>8 zp|Sua;|Qs7+S6XB$a52_j1wz?Yv7_~2vq`DZHB#d0If=mt;Y-IL)Pgw3kyji(KofXVJ{^xuOkO%%-9x@?YjA-&X? zCWpL;%uj?Q11Y{2UyI`VJ8Vk%-Pmr{}FUqqvT%PNeiYKOE#)YBYhAGEQ#WaY$ zK>LMB>J=-nf3LyuNsdZP5I%=a-x7@bZMwDQ$|K0zwHlumj2zd%ap8dBu7+VvA@i#Mi2T`ExnHER{| zJ}MiJ68YThAK|9$>KMDNeId-zVS&S>mX_CRYr^Fdt0&u>l@&}6u6i_&P81kNMaB2Z zeZ18qDz3{>DJIe0qL)h6mp|>XongbcIYoUrasA(8J5jT&M1O$`gL=hdC5A|)Gb_qV z!QTdAb_u?{%APZxyZNfsR>hq$qecP~=M>mHq%79rS63SZZPOx8X9vW%u3H%3^S`-9 zWhZpbB}Lc<=f9wJiMTacxC@Y7$ji5?r^E&tu!iJ`D{2+`Uf;XJL>&~;x;wMe-$Yl0 zV=l&D(-UbH6zo}rhNttRBsxE0o$O(2TMh>4EiW)>B2mQNP%bkzipZDYjr~o(5I$|j z(x|kwRLkAXpoq?Kdu|8A)e^AVAu&I_fT=pM<6EAOUu z!XoiWH6Onihjo&nk00g5ukSTNXVHA;Q~(ScVwU_xF@Q6I-2&g^nsVZ z)Ns*J@h)v%)07}V)sbjv?fO7(u8e(U+n(G_ymq@>+L-c9!}lYS@Y#DZP0sI%a9AgH zihiXbTFN9&Zihwd(pgKr+P>H*PDaRHaNBahx6v}~znH-Jw#FZJ6qREb4fz1}Go}g9 z!8jWW;rZ=W&RrM@{dK}-`gQKU}mIjSC8W!Kl3Snfyod%p z%J1Fkl)L8{GFFzkH@1$8F}U)ldlEthR5B;siLmg!%OC2#i>m>QkM>nh}DfWZa$n^k!(ix2yP z4C0n&J4{Z0jyG%Y_b~C_+|posGCD@SZ90O!OjXJBGQoO`_ckjhM!NcxOqyO$+rnU? zba4tBUCWF0{L>l(h@qzZ>NiDRp_EgYh{TMc)ZMy?lUKdi-F_whKg+G zJQ2qW>NNrHEsdnCC-Nfi6px8rnRF~nsQQph@?PdZ7k)LVh`DACd-RpCSGqbE-Bhv0xYBs1*csX? z!{;>ca?SA?6&)MMnx!9~i6X+QIZ)7+>??b3j?GMTt}m0|YkjG89j!Uf>AETSB0-3_ zCARR{$yyyy>W9dHt0>R-mj(Es;#<*O%nt)yT8XrLsWFWv3(+#) zUPq%}YVaWwQQYu66Oi?8aoK75hJ^78k={;55}U<>l3<9q*@`*JoK;nvZcAUb8h- TQjIo^<~2?}hnm{#Vov-ATrk8l literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/jpeg/r444.ppm b/tests/fixtures/codecs/jpeg/r444.ppm new file mode 100644 index 0000000000000000000000000000000000000000..84db23e90361c7ae52ec4f06b5e79293e5875aec GIT binary patch literal 8248 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 2) & 1, (bar >> 1) & 1, bar & 1 + r, g, b = 0.1 + 0.8 * r, 0.1 + 0.8 * g, 0.1 + 0.8 * b + else: + n = random.random() + edge = 1.0 if ((x // 3) + (y // 3)) % 2 == 0 else 0.0 + r, g, b = 0.6 * edge + 0.4 * n, 0.5 * n, 0.8 * edge + px8 += [round(v * 255) for v in (r, g, b)] + px16 += [round(v * 65535) for v in (r, g, b)] +with open("src.ppm", "wb") as f: + f.write(b"P6\n%d %d\n255\n" % (W, H)); f.write(bytes(px8)) +with open("src16.ppm", "wb") as f: + f.write(b"P6\n%d %d\n65535\n" % (W, H)) + f.write(b"".join(v.to_bytes(2, "big") for v in px16)) +EOF + +# JPEG: cjpeg encodes, djpeg (accurate integer IDCT, fancy upsampling) provides the reference pixels. +for s in "444:1x1" "422:2x1" "420:2x2" "440:1x2" "411:4x1"; do + name=${s%%:*}; f=${s##*:} + cjpeg -quality 88 -sample "$f" src.ppm > "jpeg/b$name.jpg" + djpeg -ppm "jpeg/b$name.jpg" > "jpeg/b$name.ppm" +done +djpeg -nosmooth -ppm jpeg/b420.jpg > jpeg/b420-nosmooth.ppm +cjpeg -quality 85 -sample 2x2 -progressive src.ppm > jpeg/p420.jpg && djpeg -ppm jpeg/p420.jpg > jpeg/p420.ppm +cjpeg -quality 92 -sample 1x1 -progressive src.ppm > jpeg/p444.jpg && djpeg -ppm jpeg/p444.jpg > jpeg/p444.ppm +cjpeg -quality 90 -sample 2x2 -restart 1 src.ppm > jpeg/r420.jpg && djpeg -ppm jpeg/r420.jpg > jpeg/r420.ppm +cjpeg -quality 90 -sample 1x1 -restart 5B -optimize src.ppm > jpeg/r444.jpg && djpeg -ppm jpeg/r444.jpg > jpeg/r444.ppm +cjpeg -quality 90 -grayscale src.ppm > jpeg/gray.jpg && djpeg -pnm jpeg/gray.jpg > jpeg/gray.pgm +cjpeg -quality 90 -grayscale -progressive src.ppm > jpeg/pgray.jpg && djpeg -pnm jpeg/pgray.jpg > jpeg/pgray.pgm +convert src.ppm -quality 95 -colorspace CMYK jpeg/cmyk.jpg + +# PNG: ImageMagick/libpng writers; pixels compare against src.ppm / src16.ppm. +convert src.ppm -interlace PNG png24:png/adam7.png +convert src16.ppm -define png:bit-depth=16 png48:png/rgb16.png +convert src16.ppm -interlace PNG -define png:bit-depth=16 png48:png/adam7-16.png +convert src.ppm -colorspace Gray -define png:color-type=0 -define png:bit-depth=8 png/gray8.png +convert src.ppm -colorspace Gray -depth 4 -define png:color-type=0 -define png:bit-depth=4 png/gray4.png +convert src.ppm -colorspace Gray -depth 2 -define png:color-type=0 -define png:bit-depth=2 png/gray2.png +convert src.ppm -colorspace Gray -threshold 50% -define png:color-type=0 -define png:bit-depth=1 png/gray1.png +convert src.ppm -colors 16 -transparent "$(convert src.ppm -colors 16 -format '%[pixel:p{0,40}]' info:)" png8:png/palette-trns.png +convert src.ppm -colors 16 -interlace PNG png8:png/palette-adam7.png +convert src.ppm -colors 12 -define png:color-type=3 -define png:bit-depth=4 png/palette4.png +convert src.ppm \( src.ppm -colorspace Gray \) -alpha off -compose CopyOpacity -composite png32:png/rgba.png +convert src.ppm -colorspace Gray \( src.ppm -channel R -separate \) -alpha off -compose CopyOpacity -composite -define png:color-type=4 png/graya.png +for f in gray1 gray2 gray4 gray8 graya palette-trns palette-adam7 palette4 rgba; do convert "png/$f.png" -depth 8 "png/$f.pam"; done + +# TIFF: ImageMagick/libtiff writers in every supported layout and compression. +convert src.ppm -compress LZW -define tiff:predictor=2 tiff/lzw-pred.tif +convert src.ppm -compress RLE tiff/packbits.tif +convert src.ppm -compress None -define tiff:rows-per-strip=7 tiff/none-strips.tif +convert src16.ppm -depth 16 -compress Zip -define tiff:predictor=2 tiff/deflate16-pred.tif +convert src.ppm -compress LZW -define tiff:tile-geometry=16x16 tiff/lzw-tiled.tif +tiffcp -p separate -c zip src.ppm.tmp.tif tiff/planar-zip.tif 2>/dev/null || { convert src.ppm -compress None tiff/_tmp.tif; tiffcp -p separate -c zip tiff/_tmp.tif tiff/planar-zip.tif; rm tiff/_tmp.tif; } +convert src.ppm -compress None tiff/_tmp.tif && tiffcp -c jpeg:90 -r 16 tiff/_tmp.tif tiff/jpeg-ycbcr.tif && tiffcp -c jpeg:r:90 -r 16 tiff/_tmp.tif tiff/jpeg-rgb.tif && rm tiff/_tmp.tif +convert src16.ppm -define quantum:format=floating-point -depth 32 -compress Zip -define tiff:predictor=3 tiff/float32-pred3.tif +convert src.ppm -colorspace Gray -define tiff:photometric=min-is-white -compress None tiff/gray-miniswhite.tif +ls -l jpeg png tiff diff --git a/tests/fixtures/codecs/png/adam7-16.png b/tests/fixtures/codecs/png/adam7-16.png new file mode 100644 index 0000000000000000000000000000000000000000..cf5c5c4ef5bf909c2b9e17410ce13d64fe2b9ff9 GIT binary patch literal 5265 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 aqo)u;Eq@A*G`T7l#-~h{TdmTy5WWClUpy87 literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/png/gray1.png b/tests/fixtures/codecs/png/gray1.png new file mode 100644 index 0000000000000000000000000000000000000000..c60c472319a0df9e1f5ee39946efe23814121249 GIT binary patch literal 241 zcmeAS@N?(olHy`uVBq!ia0vp^wm_`Q2qYLx&&S;dQcOwS?k)_Bce{j_0D0^sp1!W^ zueg{v70h=={qO+_P4{$h43W5ebizj7LkkGVV%8tB$ zW7)-(Qne25*LH?SOsL(e{Ai`>u8*ujN-{nsRbCG{_6mGDc1CYm+56?OQDNfwYXrSD o{F{oC{#s3TIqy`zRYd#Vjn5tT?_8P~3Unfar>mdKI;Vst00*X9b^rhX literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/png/gray2.pam b/tests/fixtures/codecs/png/gray2.pam new file mode 100644 index 0000000000000000000000000000000000000000..e5ea0dd99ef9ab847e799bcb2c83b696cd33e717 GIT binary patch literal 8296 zcmeH~TWVWD5JdBRSD`I9iJWf-3CrLFVdOlvm{n$y6CH{kS?Hn%1m=E>tE;Q3$9-jt zwx6c&PpjQ#aep^$)=!U{-QweNTCKN@`Y?TY`0?%GdGUU^oOZ9<=iSfkdhzo3d0Ky6 zZB{SSyYY+-{68Cbo%3Aq*P1i-T&>qWH)#0B2F3=?*uby-b4JE&>we}1e$JYGfq5fh zY~WTK@W14VVAj1(%tUs*35|;5Df%0!q7?EU5;Nn*K_SQQvn>5Tw45l!b&hO)tO_K_N>w zLzt3GFK&#n=!*tH$`GVXrk_=e3Iypjvw+liNfQn-lFh5KU`qi?%LaHz%S?G&c=K!; zyI{J#7pCx%y(_0MqKOM>Sz^)K1st&}=--fGIA?BFj=u^UCKqNV=zM zNO&vUK?usJOIglMvA1#@7Rt9=YKT%SK#<*J;Eyn+g`RL*1#s2=0(cc8v!q*+ONeFh z$~yu%K42QIZ(s1&Rl(tO3QgZAjK$8q< HFm!(d*D$GY literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/png/gray2.png b/tests/fixtures/codecs/png/gray2.png new file mode 100644 index 0000000000000000000000000000000000000000..2b998fd73a0280691302c5577c77306bf73b3638 GIT binary patch literal 308 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 literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/png/gray8.png b/tests/fixtures/codecs/png/gray8.png new file mode 100644 index 0000000000000000000000000000000000000000..45b3a890e8e7bd136dcf47c576045914041c7762 GIT binary patch literal 1205 zcmV;m1WNmfP)6+R`-K<@7(u!8G ze#=!5K?N%+a8bBkKKG+-S`8}A{`&rS-t(Muo^#Ioya(g}AP9gU@B&^P?+*Y7!i<;d zSJSSO60d_WBhlxUWpZaknDFX~RN zL%U%Q&y%b_v1>`x4}gi(ulG}#Np~m#!1UMqp-H*6kLNq62zVCE=lRmJ#ClFI13UPo zosst?r%1=zgt<`4P}ddYCq47I55Su~22^~#Um|5p;_)4J594*pL7`@^M8 zALjWeXbOh&vYwp%Or~5@j-(-LO;ElbPYD#gy{x@gn|TIb+vfgWusGt%nN*}5yDEpv z1-!`&a;0o&0*~_JzHW|PRN)A)!}>}09slU9wFYn&7PE zX)E_nvGeP7Gj`s#q$LefgdtJBq6C;i2%{sG^_1xScx;~qJNa)YZC zn(9}wte?haG45yKCyy&R`ksVQ9G&5%ID&QNCMyBb$nsZd1Q87y_stW z>+0Ine`I?209i8b_!2SPf!4>wmW_Et%W&eXc@WcR2b~$(CF=HsTP}(JY*HNcvpTVA zrJ!_pDolMtj}u&fiM8&=3F=aRLs@Lv6@AZz_El#`%yPzvQ4TSC z>Qh)xG`%IAF_q`|)+5&nwQx!{bNn|8O;!~EzsVx5_}&q<)!qfdnHy5H=KA-y*eSpi zTohooaX!7KiihrK;0xcDv3*3tEwqFbaVR;$=3dL0$>8arbx&MTGqS>8 zo7>9o)9{*2uI@aE51>7b7oJJ$&<#Xc+P}?l>jyvznrpK+u+p!EYM@V~os*l3jn>Qu zM}3scW9?i4k}>bJK&i`EYSy5TC^Z{wEGXxfs1mVL^mc_OT*m2gHT8`P@B;ULE1AjE T$j@|}00000NkvXXu0mjfZC+C* literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/png/graya.pam b/tests/fixtures/codecs/png/graya.pam new file mode 100644 index 0000000000000000000000000000000000000000..d12dfabe0201391ff1890b00d4a1f7d14b24485b GIT binary patch literal 5563 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 Rx;Ha-OY_nG`OJbl{|6_1{xJXm literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/png/graya.png b/tests/fixtures/codecs/png/graya.png new file mode 100644 index 0000000000000000000000000000000000000000..273e65c7e79aa465d4fc340ec8dc5da21bf4b895 GIT binary patch literal 2152 zcmV-u2$%PXP)oxQYc-O;sbi=tq?aMP8W z282W)atRO!0YV75-!JDJvwzrDJ6jd8vwwJheDgf>e((F7^S#dt(f|MkVG#e_c@M%b zvHzka{w=~UWgk$#RDr*z%ThfY3jhEJfcKoh1K1DUSbjYSEJ;7g)#ajxeH3#|vxQ~&)m;G1?JRpAncu*Ds z{%^4=y(+yby(+yby(;|}0amwKZF1QmaY3%tMtobA-8X<88lAvFyRJ$yziFBHZFXjQ z3jPg?wYcaPQ9r3}S0o?AFnV0f(dITu=9=Sr1D$rH005}upWm7_x;>5qPM6L3YM;-i zRQvvnAVNO(;O#rx%U&a=CTFCYU&u&RshM9B2xiO9W+)t9FApJW^ZkK>yr1ns(Xx#r z<7LGgp4zw;0BDpr3LgIagxg~<9j^sJpU-9|5|TL^*Pgq=<)9cRQI^f;F&V-%DkXtl zw8my195F5igHzLPFAi$I>G3L5Hb-UY^o%5v5$_LpeL13|T1q#Qs8m+HgtGgTSkCA4>aK~Z0Gl3po?sQdGWGoJj(&K`84wutqZz;&T*{fp} ztr;Fye!*oA4D)K(%+zE|VX}~jA(J~zmEy%K|E}Czd`7FA($Bv$IPCTuMYKAXCw#bDC6$Q& zcC{0Rhku120zTnQ8g+U`*aVGDcB{xF4DC=L7=@I^OXXT@ET-zt(Nicoskd1Dfr8wL zsUgk035OdQ&k}Uq3WiWjIT%OHOh-`tY@Q@bAWUB{YqVm)_#}$r;dKQPAvyMGIfgOf zhcu_ogW&1<>o*gIj%`+ZkFsxo$>_OVdjY$fn#||T&3EB7 zT3sBqZVQ`fSoq_N#X36S{8N6;$#d_{3~3@G{0IB*#1c#Ec-)q@$RjRyAjo(x7}Cv- z?GJ`3HwRz!`U8RV%P`JlhF?d}2>jezllqh-_J_}u0pN+EDgBOe!*da^MvHz*h{oYa zZ$q-|MGJx$7d6_s`QCm~tlL|>HkngX5eU$z+spicYn}UcU%8sXrBZ4e@+4V;V8~!B z$i3KNu{vG3;{2TFw##x}tOH~SJ3Qn}GlipOw0Eh**?+gz2-riYGr%5G7Q?4kMI55nJcY6}( zi3}DqCT4cNci_e?t36B5KjiUn*?2sWXflJls-mMC8V{Nm%#65?Gozz$&>N%b5u-`7 z-{vry3XWA*boQ{$Txx}&Z5OpVdR*K|e;^oSeUO|4<4$der(VAHd)@RbKl#QBqZ9KB ze{p|RFW`6XK@h2A+r@?^iLiE463b?%zYl~X@X7Uqqx#uD=m><)p87Jlqub-Sn4o8yAKASfbY_7ATZ8m4E$Z)fOuGT9?H} zij~VCxeS8zb9rI`pF|p))X$!~;`ZY4c@i#Xy*x*Rp!JPE-IYMs>Q0>HB}p>lX%1&% z0*1A;pE#Sw6ASO&z1WhTLM6*(W-A`DaH-<#vIgTYTk4rfgz>w|`-t;H9%0bvA9`p9bMC297TK7I1s zr?#_~sAT--05GJ1U(e0*`bftc8fnyD_aCdx5`+(jkov~#BQW&R^B?jHrBsUJrC_jX z%h^(mR+bIDhNAkpjLS62^xV$oe|*VgSl%s^hQs!~xR~Nai`mLIjf`^=fSnLeQ}j7q z7$(XH1Y0|ruB+5;&$@zhmt1agEDWpE#F%HcMnz_eZuHvhMTMp7o7*R+<Zgj*kyskEZV?v&r#jXZxamo$Q^gUKiUt{i}aw99GW^vwvnB?kaX} zy524BHuid%`@D9ZtIy^?$Lw&#XN63z& z?)*lDvr6WUC+#@8|KQ$@RsD-eyZL*wtz{Rier(hJc=WTaWg#zrUAA>&X29gEHf?5* zA$I%b?Nfscuibts`IxIs`(cB$?<_LBcJ+tZzOzX6$Z3byuKqTw-@UZeJKGMg-Tq+? zf0EUwGJGV%N0OfrHr3~GSHC3RAD&ZxzMk^~`0CBZ<0l)m{5xP}@2?^)1Q0pzzirs6 zqE!WfqLo&1^a0V?L8w5afl!q*1Q0xK}0})iHm0%EQ3XN0>y}srOIn70)%4HJ(TAT@Q9{eS+f>_x4 zO2$)#A*Zb2gB#BnaR>)o6+%w+WREb2NocVueQ4z%)WjNTKs`N3WK3eI+YGyz<6o?Y=AZ%hThY|WfGmk=OBDtDw zQE{r!0O0XqkBSwJG@PNyk;Y!cL4Y9AL=ZyIfz@oR-K~RYx0n|j5<{;9v)fprSb0ZMQp*apK2$ts1bY_JkEvhnr zZwTMJU?KuXBo6|I!m7Hgh~xAD$t*{!Rp?#70iiijT7)o}P6jvmfeXN4fr zY*}#-DSZSvHDU6A=*emf5eOoHl!mPAH7VzU$SJ3Q$N_|)N*|pCgK%ZdGfM(^X8A1O za&Xq1O94W&v@()f39K3CELDP>>hCRBX+^Y!1|K0Hr#jP8Xv5JN4tzmWn%hPQ7$KlS o)(BN;m5>lXGy$}QDFK{Qol74OVt6(1T!g)M5rGzG5mq>V0g0Egl>h($ literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/png/palette-adam7.png b/tests/fixtures/codecs/png/palette-adam7.png new file mode 100644 index 0000000000000000000000000000000000000000..6f333e4d668dd0806192f3cffba081a3785f442e GIT binary patch literal 920 zcmV;J184k+P)004R> z004l5008;`004mK004C`008P>0026e000+ooVrmw0000mP)t-sFf7i1Hh|77Fi5ku zwzEhZ<>ch$8xs@_8s-|?Bi-KP-mDkQ=V8n^MgSx(08?lH?4yUX00007bV*G`2kHs} z2_QHr<>lP~00QJmL_t(Y$L*Hua;q>5gbg9MihOzhw>{qqOleBm&h%GjjwhwWlGc*E zUMHoLrfHt%biXl{Wl1@`-Dg`L?=SAnODmpoFRhna(>aQmWxa^XUbM-fm;f z$b8RXBynEyIfWm6caMymjObZTZgisQ8HUuV>oDn_3wA_SbU4A2H4WC)uM*~4NsK*jub`u9h*5JOPh2LOyBNToUM6{NuFr92!2`Hgu zuTdli0>9qVi!ps1^Y!>~^d-XgfnTkko{9cpNYP%5lfb=*me=#a(kZx*ze|i|c@AFB z<3scn!0XU)1P7UiMDC;>#2)0{`8`x~9E1PSe<|A07PP=P!iWlb!3~8&r=LAa12y`u?$p%px>1H(KwB=aZ~LChmFT$}hLEXMVSGBJnR zaW`(z;At`WcBF=zF)-v0UW*iy9w-jNMgGc@8x--;d(={tO86W($5X(b$n7YuA&;Op z<{Hfq7z1Fw;@Yo3a;{5wClESkas uQE0TOZP`}bEh-`urKee0DfX=~wfqCVNJt06vqhT#0000^^-z+MkxAV)9~Kjt`2>jnk^DINUj`R*ln*&8n;D$}hUB z`lYWczv%w$p5wW-bq@cE=eGQ|{hZ@7Y5V$b^xU?`RPRrCE{~2YBKKXemhM@Hr#$YD zkILHLyyzERj96=WjfeG%^SN-}E^_o7_wV95cMiYXZ|aLPO|iD`&o9=i7&*^iT|D2M zKj*aJ6JJp$`i$3go>Sc2+RE;xp7*Qf=xNz?>TTJ*JKi+w4IQsn$;dQRV)o<$A z{#AV1lk?LAtMk+Zcki2I_rFeV;%gD7iMJ-4roQzC-|MD%k&o-tZr`~zSQNQ;kch2) zTdV3~*;(cOJ0te_-j}K_mU%q;dREoNBEQt4zua}5U+~`Z{JUO!rn&37XAIsy=d15o zoJZZ~8od8(&;Op~zQYmgzt2~H!~5T`{x^)zK<>9XV*T&-)%TPBzpDSQ>i?hT-@E&F zlKsM%wcBK0i#C^^-?YUxu-q$p$|q~ea}LF&ZY;RJcq1XcTe@f@h;AMxnyvInLYg!E?XQ)rsFE#iCxEjbv$Nkl! zM_dowJ16Rhliihi)aM=@GCX^jOOJeexEFU9YT)*WJ6Bz@e#j{gT|zIBFHR5Py!4rX z6W}?0YH^>)kGNjQ;O>O39#TFv0z93qUhI+24(gNP#u?T;_mmH=mRvHJ{cF)oMiwWl!whkH@Q%Lo)gjYkaBrU&eUYyY*)vr~Z)i{h2V*XLwaH-2Aji4x7(Jln zKGdCy4!VSVcYvSnEmz!rwc~#1L_Re_eX=@a_ja!S!O;;%gPPjvI2+s^XF3;L9cIRJ z0jD?ixDzwr8qTK2xn%hEL>>9=%53WNgQ+hLUmQ#vKEVuevNOfqNqz9Rk9_si@;shhWEY|e%nJ%%&%pq^Z^TGZS}9c%EM z?>Ugc#GOeG{b*5x=UgxXy~uYieEO}S<7~00MJ;MkQ;Qt6)Nw}i1{YjyYGU-sr4G-z YsXjP6dq&jbS#a-ph|?42ij(300A&$(B>(^b literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/png/palette-trns.png b/tests/fixtures/codecs/png/palette-trns.png new file mode 100644 index 0000000000000000000000000000000000000000..93807bb3eccc19b55229cd8ac5ef530991d47de3 GIT binary patch literal 727 zcmV;|0x127P)004R> z004l5008;`004mK004C`008P>0026e000+ooVrmw0000mP)t-s6BG?FEY5&7fX*y1 zNVB%Kvq&4|icJdkkCX<-hmt_yVjo$}fqfhtI%W@z6 zh2To}a$~mIx-+kBE7iIeqiuz~wLQ=e^aK6JX!mK6K0M9Fbc>qsRJwav@NPDTN9LR! z{hEdNsF>z+(l@{nc+armZeRPk8hj820>~OJD#k;03*#^a2x~-G49KMmlF*m2nnPfl>IWV^hmJpgfn9zAMYGNK!{pX=# zVGxMnuvVoH76Pdt9?2e%n1uw>a!2_Kq}anuq9asRvPU2vY=-XEg=ivbL!jqk2`*RA zr+%uOUKqZX)L@2eR%z0VZ`meE+%knzcJ?wra4!tfIt45tx5}QJmP~+dwnGffqw4I8RP6T}oKlxy>IVT12 zUZjN!ht1yWuC?~M$0R~G&u1S_m)rIH+0kshIz3r$=T8^2_Y`Qyc6 zwtcrb+kV=t=I19bXR9~M_40gncyKlFe7%3615G_w2Zx*<5g%9wW{$kZ6TIcIYhe36 z_Q1RC<+-jQO_RLF?l+Et3`x6F%PUmekbpGSI}zJ|h#LO?#6G&XthZPDosV**FiA*# z`(=;%>+_!rAM3FCFHaNrCe`J|Q9YprO!6TA(8PAErpXZ71|K-ac9f=u(NKiGJ{sPS zk~Ss@*&xGnHV*M0rMaWA>$~R_nu{7`tc%9&6C2x6qE?e}qw2QPzk9+eX=Jb_pJ}T3PWcrZY!e0{q{K6kG z_yK(JYL5!Se+Sh3Br-w}fy3WD7zN=ls?y34ni6R7Q3Z{s?gEh}qB8_QRDd9ksu%&4 zsI9_85|n^YD=Gv=5pz0bo#qOosy=}F0LHnh=y6VLXpY$)p;iXaDu^2$sR@aduU1un za!`5Oa6r5b189XxXC;7+a?ABM2%svr#D`H1LVaB4 zc2!1_07n8Kecc6OBtXcHmF6z01UU3j8A)>@g+ng~q;WPR6^>RShC~HOuQMEJ;RKR_q0oQ_W>oD-eYGP<;!n1VI=Zj^zn$=a`p2r8>sFD(*4)Xl{o_FBt@~ z$EQKE1;iDqr0Gf3hZ-M~=mP;9L=`nYyz7DvH zsG2K;=F!S^Y9)x^3@Cz?1V9k|W1e-|8c7G)p~n`ji@+IG$=N9c?1iedG8IUy f@K0<&M||K*Go;QSxi^@JL@!MQn(^d#0}y@#qbIXs literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/png/palette4.png b/tests/fixtures/codecs/png/palette4.png new file mode 100644 index 0000000000000000000000000000000000000000..38f588a61a0963c15cb41235e159b22a200cd486 GIT binary patch literal 691 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 P00000NkvXXu0mjfUO7eo literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/png/rgba.pam b/tests/fixtures/codecs/png/rgba.pam new file mode 100644 index 0000000000000000000000000000000000000000..9b59332ca039028d22063f79ab9bf6b130413a95 GIT binary patch literal 11047 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 W2f!g%g8u>&w_-T} literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/png/rgba.png b/tests/fixtures/codecs/png/rgba.png new file mode 100644 index 0000000000000000000000000000000000000000..2cf5a36fa2ff43ec5c4d66b2ce202ffe55e3d1b0 GIT binary patch literal 3575 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 literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/src.ppm b/tests/fixtures/codecs/src.ppm new file mode 100644 index 0000000000000000000000000000000000000000..d0c8f4589af79e621b20f7725d3f6843a4a76a98 GIT binary patch literal 8248 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 Ezw9-zuC5|)R-1(ngU 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 OkSQU!S5~$!<^KW#lq8G* literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/tiff/deflate16-pred.tif b/tests/fixtures/codecs/tiff/deflate16-pred.tif new file mode 100644 index 0000000000000000000000000000000000000000..03855b817fd631434a72df6d1fd6b4a35084ed87 GIT binary patch literal 5288 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 JZsjr7e*h*c3?u*m literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/tiff/float32-pred3.tif b/tests/fixtures/codecs/tiff/float32-pred3.tif new file mode 100644 index 0000000000000000000000000000000000000000..85ab48d6bcb373a0f926caa32f7dacfc74de353c GIT binary patch literal 8876 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 literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/tiff/jpeg-rgb.tif b/tests/fixtures/codecs/tiff/jpeg-rgb.tif new file mode 100644 index 0000000000000000000000000000000000000000..36dc1b3a58501c88c851630842525badccd1464e GIT binary patch literal 4768 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 literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/tiff/jpeg-ycbcr.tif b/tests/fixtures/codecs/tiff/jpeg-ycbcr.tif new file mode 100644 index 0000000000000000000000000000000000000000..389a331f208c67f800ca4cc43c418df94b5e1f1d GIT binary patch literal 2800 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 Bfjj^J literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/tiff/lzw-pred.tif b/tests/fixtures/codecs/tiff/lzw-pred.tif new file mode 100644 index 0000000000000000000000000000000000000000..5825b3017b12ee3bd1114a5bfd888a8d91f5b1e4 GIT binary patch literal 3670 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 A+W-In literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/tiff/lzw-tiled.tif b/tests/fixtures/codecs/tiff/lzw-tiled.tif new file mode 100644 index 0000000000000000000000000000000000000000..6a00cd59b70e4d7f2cc02c21ca5d260e0cbb7811 GIT binary patch literal 5064 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 ZK8{I;y57$F8Ot%%yd}96>Jx?y{|j9ZI8Oio literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/tiff/none-strips.tif b/tests/fixtures/codecs/tiff/none-strips.tif new file mode 100644 index 0000000000000000000000000000000000000000..557a5155b6b531fb29f170f5bc70f78073cb2554 GIT binary patch literal 8542 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 literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/tiff/packbits.tif b/tests/fixtures/codecs/tiff/packbits.tif new file mode 100644 index 0000000000000000000000000000000000000000..ebd9b5eb448124e1b8a9300596f32f2d46a472d4 GIT binary patch literal 7942 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 AX#fBK literal 0 HcmV?d00001 diff --git a/tests/fixtures/codecs/tiff/planar-zip.tif b/tests/fixtures/codecs/tiff/planar-zip.tif new file mode 100644 index 0000000000000000000000000000000000000000..15390b00a52dcf37ea9fde637cd4a1ddfec4c74b GIT binary patch literal 2430 zcmYk8c|6qHAI85kmKaOP#Mq6pr7S7RwUm7;MwG14SQ@TuW9M38T(ULU$1aqzWQoMY zD9a2fW2|#6V{BnaDG_(vpFe)*yv}*v=XpJ!bIxDqbxcgo0(Kk#5Q1AH5}iLE0|4KM z7$qo=M0Ckrxp+vzPvo3P- zHeqv1S|}?LGE7KZ*I6QGFn)7E(jLm3fqxo%A)@ck*AzQg)%Fp!w)$(frzmQlJ~|zB zK>LW_Ur0V<)vEh@e!M)CvX2TK*_mGN%vfwVI0+?nijt-;pT_(AsE)mo6Srf(SosQV z%y&amwm(Kc7j)m0?ZG%S(eoOSo#*=BZeG~ryS|@4kYJaTe!qLFsNhYd9CPI)8L9EL zcaT*V!fqNOcVFC4jtc@UH7u7je7)wYW&P(@{e@FSfW)xR%#FQQ-DGmMg53%Dm+#{; zPv4rZQXjOZ6$#t&>pedCD01(oCvIpGTU91qwdh9t%q zsn`DA4z$!gR-A#(q8NAQv-ZX{>Gl0c7fANYNRCykV!s=iR39iau|Eb&;zld+Vp~++ zJxYmJ8smoDdDJgo27^2s?v-A>^~UMmHn43m7t&hBN^n?9W}xFB^s*h>o01POkZRp9)4 zeJu>B>EE-V!TM;z_s?Q^{Vy}JA;)hka|JGzK(!6-h|;||8NH;JL&a=xvxn$NkMV*ZU9P04VI&DODM z#A4gCvo42NSLi>Lr<1Q+eDrYXd=ntwTIyz9*-=RRW1FK3_9x|(cHv}1L``Z8LM?K# zF>J2XQ>O{*o{l=}jfwjserOQgZB{+(Z5npMs!|4iYAJqlJI(zH1%^H&H4 zb2pKWZHPrBBdXBwX0BMKc1#laeRxf7y{i%;cYa82sSEnn73mKV?gSPjZ+EQjG&a;y|0*k3Y71HsoKRTeu_P3RS#JyX z2yuMf7B&8Bav!e~cP;J-ub7yV#`AkBx!5UFzv|x?>Vw#1GB*=QGlqGL{_{~cWc`;gGn@v~*O1U=aU4dJ~u3k{nO znnKXW^fJ^V#hO&Im0312FL0%SAZssX)lW1}yk}sp+DbN-Y6*E=kH*&}QjOUBdh=e_ zy4!f@ECqV40Z9t~`~ttad4L9Fb-G#i$ySo7W`iPlkf8u} z8YeirO~isWW?!EXsLF}H;pPzEH#S5Qyd^`5NOexgs&sr%jxiwq;l)tddf$)T@Jciv zk`M?Kj+`N3e470RK6u`9!1%I7J%l)jX7QQwecv1AP-S$YvL^G(y&UCZerO>5t5%X@(vJ+43dk+_g)ir9)*EUI zNBjimibpIbr9$<<*uEzXiKw6r6S^#gpQBY`leyB2xB6M?mVfTlU36A-9%HKc0woVvO(9~NI2BMR5e<^P2 z`1|Z1u~oJB0Lpybf;aBsJ&YW=Z!NxLUFSgV&UgrpsOV-x&#u}$JNmJ~+Pr4|`)2kh z!N*qLII~>I5bRL8DVjEO$)9VUFXbWvQTusgNOhok6#FRC^_&{W^2ITtVwv7@6szL;aj?*;zRtJ&S8G$#G4s^&MGx zk8$Nyl1j(82nUFPvOJ?pH}5n+p_*~vRR{UfmO~>ARbji8tLg!R!FpwmnW{=tE^y-( zJ`ITrmGA&7hBL?z+#dl8+$<~vp|8e(fHZT}0