From d9c1a386dbf58e6a07e587718406dd5124a432e8 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 19 Sep 2024 14:51:21 +0930 Subject: [PATCH] lib/uncompng: add new Go package --- lib/uncompng/uncompng.go | 498 ++++++++++++++++++++++++++++++++++ lib/uncompng/uncompng_test.go | 163 +++++++++++ 2 files changed, 661 insertions(+) create mode 100644 lib/uncompng/uncompng.go create mode 100644 lib/uncompng/uncompng_test.go diff --git a/lib/uncompng/uncompng.go b/lib/uncompng/uncompng.go new file mode 100644 index 00000000..1c0a821c --- /dev/null +++ b/lib/uncompng/uncompng.go @@ -0,0 +1,498 @@ +// Copyright 2024 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT + +// ---------------- + +// Package uncompng encodes pixel data as not-compressed PNG-formatted bytes. +// The outputs are valid PNG files but avoids any compression techniques built +// into the PNG format. This obviously results in larger files than what the +// standard library's image/png package produces. Most programmers should use +// the standard package instead. +// +// The main purpose of this alternative PNG-encoding package is its simplicity +// of implementation, including all of its transitive dependencies. Its Go code +// can easily be studied (if you want to learn about the PNG file format), +// tested (the test code can depend on all of the standard library, including +// its image/png package), customized or ported to other languages. Unlike the +// standard package, this package has only two dependencies (the errors.New +// function and the io.Writer interface) and both are trivial. +// +// A secondary purpose is that, when starting with a slice of pixel data, +// producing an uncompressed PNG is faster than producing a compressed one - an +// extreme example of the general trade-off between compression speed and +// compression ratio. Similarly, decoding an uncompressed PNG can also be +// faster, even if the uncompressed PNG is bigger (in terms of byte size). If +// using PNG as a commonly-spoken format between two processes (connected by a +// Unix-like pipe) or between two libraries within the same process, and the +// transient PNG data never hits a disk drive or bandwidth-limited network, it +// may be better (faster) overall to skip any compression and decompression on +// either side of the communication channel. +// +// The Encoder.Encode method also makes no further memory allocations (above +// whatever its given io.Writer makes, if any). It is a lower-level API. See +// the encodeImage function in this package's test code for a higher-level API +// (with more dependencies and without the no-allocation guarantee) that takes +// an image.Image argument. +package uncompng + +import ( + "errors" + "io" +) + +// ColorType states how to interpret the []byte pixel data as colors. +type ColorType byte + +const ( + // ColorTypeGray means 1 byte per pixel. + // + // This matches Go's image.Gray.Pix layout. + ColorTypeGray = ColorType(1) + + // ColorTypeRGBX means 4 bytes per pixel. Red, Green, Blue and the 4th + // channel is ignored. + // + // This matches Go's image.RGBA.Pix and image.NRGBA.Pix layouts, provided + // that all of the pixels' alpha values are 0xFF. + ColorTypeRGBX = ColorType(2) + + // ColorTypeRGBX means 4 bytes per pixel. Red, Green, Blue and Alpha. RGB + // uses non-premultiplied alpha. + // + // This matches Go's image.NRGBA.Pix layout. If all of the pixels' alpha + // values are 0xFF then either ColorTypeRGBX or ColorTypeNRGBA will produce + // the same PNG output (in terms of pixels) but smaller (ColorTypeRGBX) or + // larger (ColorTypeNRGBA) output in terms of byte count. + ColorTypeNRGBA = ColorType(3) +) + +func (c ColorType) pngFileFormatEncoding() byte { + // https://www.w3.org/TR/2003/REC-PNG-20031110/#6Colour-values + switch c { + case ColorTypeGray: + return 0 + case ColorTypeRGBX: + return 2 + case ColorTypeNRGBA: + return 6 + } + return 0xFF +} + +// Depth is the number of bits per channel. +// +// This package only supports a depth of 8. In the future, it might also +// support a depth of 16. +type Depth byte + +const ( + Depth8 = Depth(8) +) + +// Encoder is an opaque type that can convert a slice of pixel data to +// PNG-formatted bytes. +// +// It contains all of the buffers needed for the Encode method. Once the +// Encoder itself is allocated, Encoder.Encode makes no further allocations +// (above whatever its given io.Writer makes, if any). +// +// It can be re-used (but it is not thread-safe). One Encoder can make multiple +// Encode calls, each call producing a complete, stand-alone PNG image. +type Encoder struct { + // buf is the fixed-size buffer to accumulate PNG-formatted output. + // + // A minimal PNG file consists of: + // - An 8-byte magic signature. + // - An IHDR chunk. + // - One or more IDAT chunks. + // - An IEND chunk. + // + // Each chunk consists of: + // - A 4-byte chunk payload length. + // - A 4-byte chunk type. + // - The chunk payload. + // - A 4-byte CRC-32/IEEE checksum of the chunk type and payload. + // + // Concatenating the IDAT payloads produces a ZLIB-compressed data stream. + // The ZLIB-decoded data consists of (((BPP * W) + 1) * H) bytes, where: + // - BPP is the number of bytes per pixel (e.g. 4 for RGBA). + // - W is the image width in pixels. + // - H is the image height in pixels. + // + // The +1 is because every row's pixel data is preceded by one byte for the + // per-row PNG filter. This package hard-codes a zero byte (no filtering). + // + // For a normal PNG encoder, the ZLIB-encoded data is shorter than the + // ZLIB-decoded data (as compression is the whole point of ZLIB). This PNG + // encoder prioritizes simplicity of implementation over compression ratio, + // so the ZLIB-encoded data is actually longer. The ZLIB-formatted stream + // consists of: + // - A 2-byte header. + // - A raw DEFLATE stream. + // - A 4-byte Adler-32 checksum of the ZLIB-decoded data. + // + // A raw DEFLATE stream is just one or more DEFLATE blocks. + // + // The DEFLATE format allows for uncompressed and compressed blocks. This + // encoder only emits uncompressed blocks. Each uncompressed block is: + // - A 1-byte header (0 means non-final, 1 means final). + // - A 2-byte u16le payload length. + // - That 2-byte u16le payload length again, xor'ed with 0xFFFF. + // - The uncompressed block payload (literal bytes). + // + // ---- + // + // After that long preamble, here's the data layout of the buf field. Each + // time a slice of buf is passed to an io.Writer, it contains exactly one + // IDAT chunk. The final time will also contain an IEND chunk after the + // IDAT chunk, unless it won't fit, in which case there will be one more + // Write call with just the 12-byte IEND chunk (and no IDAT chunk). + // + // For all but the first Write, the 4-byte IDAT chunk length starts at + // buf[0x0000:]. For the first Write, it will start at buf[0x0021:], since + // it is preceded by the magic signature and the IHDR chunk. + // + // Either way, each IDAT chunk contains exactly one DEFLATE block (an + // uncompressed block). The very first IDAT (in the very first Write) also + // contains the 2-byte ZLIB header. The very last IDAT also contains the + // 4-byte Adler-32 checksum. + // + // Each DEFLATE uncompressed block's payload spans e.buf[ei:ej], for two + // indexes ei and ej, either explicit local variables or implicit state. + // Writing pixel data to the Encoder increments ej, flushing to the + // io.Writer beforehand (which resets ej = ei) if the data won't fit. ei is + // 0x0030 before the first Write call and at 0x000D afterwards. + // + // "The data won't fit" if ej would end up greater than ejMax, where ejMax + // is the size of the buffer (0x10000) minus 8 bytes that leaves enough + // room for two trailing 4-byte checksums (Adler-32 and CRC-32/IEEE). + // + // The last 4 bytes are also repurposed to hold the in-progress Adler-32 + // checksum state, as these 4 bytes won't be overwritten unless emitting + // the final IDAT chunk (containing the final DEFLATE block). + buf [65536]byte +} + +const ( + eiFirst = 0x0030 + eiLater = 0x000D + ejMax = 0xFFF8 +) + +// Encode writes the pixel data to w. It makes no allocations above whatever +// w.Write makes, if any. +// +// pix holds the pixel data, either 1 or 4 bytes per pixel depending on the +// colorType. width and height are measured in pixels. stride is measured in +// bytes. depth must be Depth8 although this might be relaxed in the future. +func (e *Encoder) Encode(w io.Writer, pix []byte, width int, height int, stride int, depth Depth, colorType ColorType) error { + if (width < 0) || (height < 0) || (depth != Depth8) || (colorType.pngFileFormatEncoding() == 0xFF) { + return errors.New("uncompng: invalid argument") + } else if (width > 0xFFFFFF) || (height > 0xFFFFFF) { + return errors.New("uncompng: unsupported image size") + } + + e.init(width, height, depth, colorType) + ej := eiFirst + + for y := 0; y < height; y++ { + if (ej + 1) > ejMax { + if err := e.flush(w, ej, false); err != nil { + return err + } + ej = eiLater + } + e.buf[ej+0] = 0 // PNG 'none' filter. + ej += 1 + + row := pix[y*stride:] + + switch colorType { + case ColorTypeGray: + row = row[:1*width] + for x := 0; x < width; x++ { + if (ej + 1) > ejMax { + if err := e.flush(w, ej, false); err != nil { + return err + } + ej = eiLater + } + e.buf[ej+0] = row[0] + ej += 1 + row = row[1:] + } + + case ColorTypeRGBX: + row = row[:4*width] + for x := 0; x < width; x++ { + if (ej + 3) > ejMax { + if err := e.flush(w, ej, false); err != nil { + return err + } + ej = eiLater + } + e.buf[ej+0] = row[0] + e.buf[ej+1] = row[1] + e.buf[ej+2] = row[2] + ej += 3 + row = row[4:] + } + + case ColorTypeNRGBA: + row = row[:4*width] + for x := 0; x < width; x++ { + if (ej + 4) > ejMax { + if err := e.flush(w, ej, false); err != nil { + return err + } + ej = eiLater + } + e.buf[ej+0] = row[0] + e.buf[ej+1] = row[1] + e.buf[ej+2] = row[2] + e.buf[ej+3] = row[3] + ej += 4 + row = row[4:] + } + } + } + + return e.flush(w, ej, true) +} + +func (e *Encoder) init(width int, height int, depth Depth, colorType ColorType) { + // PNG magic signature. + e.buf[0x0000] = 0x89 + e.buf[0x0001] = 'P' + e.buf[0x0002] = 'N' + e.buf[0x0003] = 'G' + e.buf[0x0004] = 0x0D + e.buf[0x0005] = 0x0A + e.buf[0x0006] = 0x1A + e.buf[0x0007] = 0x0A + + // IHDR chunk length. + e.buf[0x0008] = 0 + e.buf[0x0009] = 0 + e.buf[0x000A] = 0 + e.buf[0x000B] = 0x0D + // IHDR chunk type. + e.buf[0x000C] = 'I' + e.buf[0x000D] = 'H' + e.buf[0x000E] = 'D' + e.buf[0x000F] = 'R' + // IHDR chunk payload. + e.buf[0x0010] = byte(width >> 24) + e.buf[0x0011] = byte(width >> 16) + e.buf[0x0012] = byte(width >> 8) + e.buf[0x0013] = byte(width >> 0) + e.buf[0x0014] = byte(height >> 24) + e.buf[0x0015] = byte(height >> 16) + e.buf[0x0016] = byte(height >> 8) + e.buf[0x0017] = byte(height >> 0) + e.buf[0x0018] = byte(depth) + e.buf[0x0019] = colorType.pngFileFormatEncoding() + e.buf[0x001A] = 0 // Compression method. + e.buf[0x001B] = 0 // Filter method. + e.buf[0x001C] = 0 // Interlace method. + // IHDR CRC-32/IEEE checksum. + ihdrCRC32 := crc32IEEE(e.buf[0x000C:0x001D]) + e.buf[0x001D] = byte(ihdrCRC32 >> 24) + e.buf[0x001E] = byte(ihdrCRC32 >> 16) + e.buf[0x001F] = byte(ihdrCRC32 >> 8) + e.buf[0x0020] = byte(ihdrCRC32 >> 0) + + // IDAT chunk length placeholder. + e.buf[0x0021] = 0 + e.buf[0x0022] = 0 + e.buf[0x0023] = 0 + e.buf[0x0024] = 0 + // IDAT chunk type. + e.buf[0x0025] = 'I' + e.buf[0x0026] = 'D' + e.buf[0x0027] = 'A' + e.buf[0x0028] = 'T' + // ZLIB header: CM=8, CINFO=7, FDICT=0, FLEVEL=0. See RFC 1950. + e.buf[0x0029] = 0x78 + e.buf[0x002A] = 0x01 + // DEFLATE uncompressed block header, with 4-byte placeholder for length. + e.buf[0x002B] = 0 + e.buf[0x002C] = 0 + e.buf[0x002D] = 0 + e.buf[0x002E] = 0 + e.buf[0x002F] = 0 + // eiFirst is therefore 0x0030. + + // AdlerB=0, Adler32A=1. + e.buf[0xFFFC] = 0 + e.buf[0xFFFD] = 0 + e.buf[0xFFFE] = 0 + e.buf[0xFFFF] = 1 +} + +func (e *Encoder) updateAdler32(ei int, ej int) { + b := (uint32(e.buf[0xFFFC]) << 8) | uint32(e.buf[0xFFFD]) + a := (uint32(e.buf[0xFFFE]) << 8) | uint32(e.buf[0xFFFF]) + for ei < ej { + end := ei + 5552 + if end > ej { + end = ej + } + for ; ei < end; ei++ { + a += uint32(e.buf[ei]) + b += a + } + a %= 65521 + b %= 65521 + } + e.buf[0xFFFC] = byte(b >> 8) + e.buf[0xFFFD] = byte(b >> 0) + e.buf[0xFFFE] = byte(a >> 8) + e.buf[0xFFFF] = byte(a >> 0) +} + +func (e *Encoder) flush(w io.Writer, ej int, final bool) error { + // Update the IDAT chunk length placeholder. + crc32Start, ei := 0, 0 + if e.buf[0x0004] == 0x0D { // First IDAT chunk. + idatChunkLen := ej - 0x0029 + if final { + idatChunkLen += 4 + } + e.buf[0x0021] = byte(idatChunkLen >> 24) + e.buf[0x0022] = byte(idatChunkLen >> 16) + e.buf[0x0023] = byte(idatChunkLen >> 8) + e.buf[0x0024] = byte(idatChunkLen >> 0) + crc32Start, ei = 0x0025, eiFirst + } else { // Later IDAT chunk. + idatChunkLen := ej - 0x0008 + if final { + idatChunkLen += 4 + } + e.buf[0x0000] = byte(idatChunkLen >> 24) + e.buf[0x0001] = byte(idatChunkLen >> 16) + e.buf[0x0002] = byte(idatChunkLen >> 8) + e.buf[0x0003] = byte(idatChunkLen >> 0) + crc32Start, ei = 0x0004, eiLater + } + + // Update the DEFLATE uncompressed block header placeholder. + deflateBlockLen := ej - ei + e.buf[ei-5] = btou8(final) + e.buf[ei-4] = 0x00 ^ byte(deflateBlockLen>>0) + e.buf[ei-3] = 0x00 ^ byte(deflateBlockLen>>8) + e.buf[ei-2] = 0xFF ^ byte(deflateBlockLen>>0) + e.buf[ei-1] = 0xFF ^ byte(deflateBlockLen>>8) + + // Update (and maybe write) the Adler-32 checksum. + e.updateAdler32(ei, ej) + if final { + e.buf[ej+0] = e.buf[0xFFFC] + e.buf[ej+1] = e.buf[0xFFFD] + e.buf[ej+2] = e.buf[0xFFFE] + e.buf[ej+3] = e.buf[0xFFFF] + ej += 4 + } + + // Write the CRC-32/IEEE checksum. + idatCRC32 := crc32IEEE(e.buf[crc32Start:ej]) + e.buf[ej+0] = byte(idatCRC32 >> 24) + e.buf[ej+1] = byte(idatCRC32 >> 16) + e.buf[ej+2] = byte(idatCRC32 >> 8) + e.buf[ej+3] = byte(idatCRC32 >> 0) + ej += 4 + + if !final { + if _, err := w.Write(e.buf[:ej]); err != nil { + return err + } + // Write (or reserve space for) 0x000D bytes total: + // - 4 bytes for the IDAT chunk length placeholder. + // - 4 bytes for the IDAT chunk type. + // - 5 bytes for the DEFLATE uncompressed block header placeholder. + // + // eiLater is therefore 0x000D. + e.buf[0x0004] = 'I' + e.buf[0x0005] = 'D' + e.buf[0x0006] = 'A' + e.buf[0x0007] = 'T' + return nil + } + + const iendChunk = "\x00\x00\x00\x00IEND\xAE\x42\x60\x82" + writeSeparateIENDChunk := (ej + len(iendChunk)) > len(e.buf) + if !writeSeparateIENDChunk { + copy(e.buf[ej:ej+len(iendChunk)], iendChunk) + ej += len(iendChunk) + } + + if _, err := w.Write(e.buf[:ej]); err != nil { + return err + } + + if writeSeparateIENDChunk { + copy(e.buf[:], iendChunk) + if _, err := w.Write(e.buf[:len(iendChunk)]); err != nil { + return err + } + } + + return nil +} + +func btou8(a bool) uint8 { + if a { + return 1 + } + return 0 +} + +func crc32IEEE(b []byte) uint32 { + hash := uint32(0xFFFF_FFFF) + for _, v := range b { + hash = crc32IEEETable[uint8(hash)^v] ^ (hash >> 8) + } + return hash ^ uint32(0xFFFF_FFFF) +} + +var crc32IEEETable = [256]uint32{ + 0x0000_0000, 0x7707_3096, 0xEE0E_612C, 0x9909_51BA, 0x076D_C419, 0x706A_F48F, 0xE963_A535, 0x9E64_95A3, + 0x0EDB_8832, 0x79DC_B8A4, 0xE0D5_E91E, 0x97D2_D988, 0x09B6_4C2B, 0x7EB1_7CBD, 0xE7B8_2D07, 0x90BF_1D91, + 0x1DB7_1064, 0x6AB0_20F2, 0xF3B9_7148, 0x84BE_41DE, 0x1ADA_D47D, 0x6DDD_E4EB, 0xF4D4_B551, 0x83D3_85C7, + 0x136C_9856, 0x646B_A8C0, 0xFD62_F97A, 0x8A65_C9EC, 0x1401_5C4F, 0x6306_6CD9, 0xFA0F_3D63, 0x8D08_0DF5, + 0x3B6E_20C8, 0x4C69_105E, 0xD560_41E4, 0xA267_7172, 0x3C03_E4D1, 0x4B04_D447, 0xD20D_85FD, 0xA50A_B56B, + 0x35B5_A8FA, 0x42B2_986C, 0xDBBB_C9D6, 0xACBC_F940, 0x32D8_6CE3, 0x45DF_5C75, 0xDCD6_0DCF, 0xABD1_3D59, + 0x26D9_30AC, 0x51DE_003A, 0xC8D7_5180, 0xBFD0_6116, 0x21B4_F4B5, 0x56B3_C423, 0xCFBA_9599, 0xB8BD_A50F, + 0x2802_B89E, 0x5F05_8808, 0xC60C_D9B2, 0xB10B_E924, 0x2F6F_7C87, 0x5868_4C11, 0xC161_1DAB, 0xB666_2D3D, + 0x76DC_4190, 0x01DB_7106, 0x98D2_20BC, 0xEFD5_102A, 0x71B1_8589, 0x06B6_B51F, 0x9FBF_E4A5, 0xE8B8_D433, + 0x7807_C9A2, 0x0F00_F934, 0x9609_A88E, 0xE10E_9818, 0x7F6A_0DBB, 0x086D_3D2D, 0x9164_6C97, 0xE663_5C01, + 0x6B6B_51F4, 0x1C6C_6162, 0x8565_30D8, 0xF262_004E, 0x6C06_95ED, 0x1B01_A57B, 0x8208_F4C1, 0xF50F_C457, + 0x65B0_D9C6, 0x12B7_E950, 0x8BBE_B8EA, 0xFCB9_887C, 0x62DD_1DDF, 0x15DA_2D49, 0x8CD3_7CF3, 0xFBD4_4C65, + 0x4DB2_6158, 0x3AB5_51CE, 0xA3BC_0074, 0xD4BB_30E2, 0x4ADF_A541, 0x3DD8_95D7, 0xA4D1_C46D, 0xD3D6_F4FB, + 0x4369_E96A, 0x346E_D9FC, 0xAD67_8846, 0xDA60_B8D0, 0x4404_2D73, 0x3303_1DE5, 0xAA0A_4C5F, 0xDD0D_7CC9, + 0x5005_713C, 0x2702_41AA, 0xBE0B_1010, 0xC90C_2086, 0x5768_B525, 0x206F_85B3, 0xB966_D409, 0xCE61_E49F, + 0x5EDE_F90E, 0x29D9_C998, 0xB0D0_9822, 0xC7D7_A8B4, 0x59B3_3D17, 0x2EB4_0D81, 0xB7BD_5C3B, 0xC0BA_6CAD, + 0xEDB8_8320, 0x9ABF_B3B6, 0x03B6_E20C, 0x74B1_D29A, 0xEAD5_4739, 0x9DD2_77AF, 0x04DB_2615, 0x73DC_1683, + 0xE363_0B12, 0x9464_3B84, 0x0D6D_6A3E, 0x7A6A_5AA8, 0xE40E_CF0B, 0x9309_FF9D, 0x0A00_AE27, 0x7D07_9EB1, + 0xF00F_9344, 0x8708_A3D2, 0x1E01_F268, 0x6906_C2FE, 0xF762_575D, 0x8065_67CB, 0x196C_3671, 0x6E6B_06E7, + 0xFED4_1B76, 0x89D3_2BE0, 0x10DA_7A5A, 0x67DD_4ACC, 0xF9B9_DF6F, 0x8EBE_EFF9, 0x17B7_BE43, 0x60B0_8ED5, + 0xD6D6_A3E8, 0xA1D1_937E, 0x38D8_C2C4, 0x4FDF_F252, 0xD1BB_67F1, 0xA6BC_5767, 0x3FB5_06DD, 0x48B2_364B, + 0xD80D_2BDA, 0xAF0A_1B4C, 0x3603_4AF6, 0x4104_7A60, 0xDF60_EFC3, 0xA867_DF55, 0x316E_8EEF, 0x4669_BE79, + 0xCB61_B38C, 0xBC66_831A, 0x256F_D2A0, 0x5268_E236, 0xCC0C_7795, 0xBB0B_4703, 0x2202_16B9, 0x5505_262F, + 0xC5BA_3BBE, 0xB2BD_0B28, 0x2BB4_5A92, 0x5CB3_6A04, 0xC2D7_FFA7, 0xB5D0_CF31, 0x2CD9_9E8B, 0x5BDE_AE1D, + 0x9B64_C2B0, 0xEC63_F226, 0x756A_A39C, 0x026D_930A, 0x9C09_06A9, 0xEB0E_363F, 0x7207_6785, 0x0500_5713, + 0x95BF_4A82, 0xE2B8_7A14, 0x7BB1_2BAE, 0x0CB6_1B38, 0x92D2_8E9B, 0xE5D5_BE0D, 0x7CDC_EFB7, 0x0BDB_DF21, + 0x86D3_D2D4, 0xF1D4_E242, 0x68DD_B3F8, 0x1FDA_836E, 0x81BE_16CD, 0xF6B9_265B, 0x6FB0_77E1, 0x18B7_4777, + 0x8808_5AE6, 0xFF0F_6A70, 0x6606_3BCA, 0x1101_0B5C, 0x8F65_9EFF, 0xF862_AE69, 0x616B_FFD3, 0x166C_CF45, + 0xA00A_E278, 0xD70D_D2EE, 0x4E04_8354, 0x3903_B3C2, 0xA767_2661, 0xD060_16F7, 0x4969_474D, 0x3E6E_77DB, + 0xAED1_6A4A, 0xD9D6_5ADC, 0x40DF_0B66, 0x37D8_3BF0, 0xA9BC_AE53, 0xDEBB_9EC5, 0x47B2_CF7F, 0x30B5_FFE9, + 0xBDBD_F21C, 0xCABA_C28A, 0x53B3_9330, 0x24B4_A3A6, 0xBAD0_3605, 0xCDD7_0693, 0x54DE_5729, 0x23D9_67BF, + 0xB366_7A2E, 0xC461_4AB8, 0x5D68_1B02, 0x2A6F_2B94, 0xB40B_BE37, 0xC30C_8EA1, 0x5A05_DF1B, 0x2D02_EF8D, +} diff --git a/lib/uncompng/uncompng_test.go b/lib/uncompng/uncompng_test.go new file mode 100644 index 00000000..7723e68c --- /dev/null +++ b/lib/uncompng/uncompng_test.go @@ -0,0 +1,163 @@ +// Copyright 2024 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT + +package uncompng + +import ( + "bytes" + "image" + "image/draw" + "image/png" + "io" + "os" + "testing" +) + +func encodeImage(w io.Writer, src image.Image) error { + e := Encoder{} + b := src.Bounds() + + switch src := src.(type) { + case *image.Gray: + return e.Encode(w, src.Pix, b.Dx(), b.Dy(), src.Stride, Depth8, ColorTypeGray) + + case *image.RGBA: + if src.Opaque() { + return e.Encode(w, src.Pix, b.Dx(), b.Dy(), src.Stride, Depth8, ColorTypeRGBX) + } + + case *image.NRGBA: + if src.Opaque() { + return e.Encode(w, src.Pix, b.Dx(), b.Dy(), src.Stride, Depth8, ColorTypeRGBX) + } else { + return e.Encode(w, src.Pix, b.Dx(), b.Dy(), src.Stride, Depth8, ColorTypeNRGBA) + } + } + + tmp := image.NewNRGBA(b) + draw.Draw(tmp, b, src, b.Min, draw.Src) + return e.Encode(w, tmp.Pix, b.Dx(), b.Dy(), tmp.Stride, Depth8, ColorTypeNRGBA) +} + +func getPix(m image.Image) []byte { + switch m := m.(type) { + case *image.Gray: + return m.Pix + case *image.RGBA: + return m.Pix + case *image.NRGBA: + return m.Pix + } + return nil +} + +func TestRoundTrip(tt *testing.T) { + testCases := []string{ + "bricks-color.png", + "bricks-gray.png", + "harvesters.png", + "hibiscus.primitive.png", + "hibiscus.regular.png", + "hippopotamus.masked-with-muybridge.png", + "hippopotamus.regular.png", + } + + for _, tc := range testCases { + testRoundTrip(tt, tc) + } +} + +func testRoundTrip(tt *testing.T, basename string) { + src, err := os.Open("../../test/data/" + basename) + if err != nil { + tt.Errorf("%q: os.Open: %v", basename, err) + return + } + defer src.Close() + + img0, err := png.Decode(src) + if err != nil { + tt.Errorf("%q: png.Decode #0: %v", basename, err) + return + } + + buf := &bytes.Buffer{} + err = encodeImage(buf, img0) + if err != nil { + tt.Errorf("%q: encodeImage: %v", basename, err) + return + } + + img1, err := png.Decode(buf) + if err != nil { + tt.Errorf("%q: png.Decode #1: %v", basename, err) + return + } + + rect1, rect0 := img1.Bounds(), img0.Bounds() + if rect1 != rect0 { + tt.Errorf("%q: rect1: got %v, want %v", basename, rect1, rect0) + return + } + + pix1, pix0 := getPix(img1), getPix(img0) + if pix1 == nil { + tt.Errorf("%q: pix1 was nil", basename) + return + } else if !bytes.Equal(pix1, pix0) { + tt.Errorf("%q: pix1 differed from pix0", basename) + return + } +} + +func TestNoAllocation(tt *testing.T) { + enc := Encoder{} + pix := make([]byte, 4*3*5) + got := testing.AllocsPerRun(100, func() { + enc.Encode(io.Discard, pix, 3, 5, 4*3, Depth8, ColorTypeNRGBA) + }) + if got != 0 { + tt.Errorf("AllocsPerRun: got %v, want 0", got) + return + } +} + +type lookingForSeparateIENDChunkBuffer struct { + buf bytes.Buffer + seen bool +} + +func (z *lookingForSeparateIENDChunkBuffer) Write(b []byte) (int, error) { + const iendChunk = "\x00\x00\x00\x00IEND\xAE\x42\x60\x82" + if (len(b) == len(iendChunk)) && (string(b) == iendChunk) { + z.seen = true + } + return z.buf.Write(b) +} + +func TestWriteSeparateIENDChunk(tt *testing.T) { + lfsicb := lookingForSeparateIENDChunkBuffer{} + rect0 := image.Rect(0, 0, 65470, 1) + img0 := image.NewGray(rect0) + if err := encodeImage(&lfsicb, img0); err != nil { + tt.Fatalf("encodeImage: %v", err) + } + img1, err := png.Decode(&lfsicb.buf) + if err != nil { + tt.Fatalf("png.Decode: %v", err) + } + rect1 := img1.Bounds() + if rect1 != rect0 { + tt.Fatalf("rect1: got %v, want %v", rect1, rect0) + } + if !lfsicb.seen { + tt.Fatalf("have not seen a separate IEND chunk") + } +}