/// <summary> /// Decode the provided png file to a BGRA pixel array, Y flipped. /// </summary> /// <param name="pngData">The png file as bytes.</param> /// <param name="fileHeader">The png file's header.</param> /// <returns>The RGBA pixel data from the png.</returns> public static byte[] Decode(byte[] pngData, out PngFileHeader fileHeader) { fileHeader = new PngFileHeader(); if (!IsPng(pngData)) { Engine.Log.Warning("Tried to decode a non-png image!", MessageSource.ImagePng); return(null); } using var stream = new MemoryStream(pngData); stream.Seek(8, SeekOrigin.Current); var endChunkReached = false; byte[] palette = null; byte[] paletteAlpha = null; using var dataStream = new MemoryStream(); // Read chunks while there are valid chunks. PngChunk currentChunk; while ((currentChunk = new PngChunk(stream)).Valid) { if (endChunkReached) { Engine.Log.Warning("Image did not end with an end chunk...", MessageSource.ImagePng); continue; } switch (currentChunk.Type) { case PngChunkTypes.HEADER: { Array.Reverse(currentChunk.Data, 0, 4); Array.Reverse(currentChunk.Data, 4, 4); fileHeader.Width = BitConverter.ToInt32(currentChunk.Data, 0); fileHeader.Height = BitConverter.ToInt32(currentChunk.Data, 4); fileHeader.BitDepth = currentChunk.Data[8]; fileHeader.ColorType = currentChunk.Data[9]; fileHeader.FilterMethod = currentChunk.Data[11]; fileHeader.InterlaceMethod = currentChunk.Data[12]; fileHeader.CompressionMethod = currentChunk.Data[10]; // Validate header. if (fileHeader.ColorType >= ColorTypes.Length || ColorTypes[fileHeader.ColorType] == null) { Engine.Log.Warning($"Color type '{fileHeader.ColorType}' is not supported or not valid.", MessageSource.ImagePng); return(null); } if (!ColorTypes[fileHeader.ColorType].SupportedBitDepths.Contains(fileHeader.BitDepth)) { Engine.Log.Warning($"Bit depth '{fileHeader.BitDepth}' is not supported or not valid for color type {fileHeader.ColorType}.", MessageSource.ImagePng); } if (fileHeader.FilterMethod != 0) { Engine.Log.Warning("The png specification only defines 0 as filter method.", MessageSource.ImagePng); } break; } case PngChunkTypes.DATA: dataStream.Write(currentChunk.Data, 0, currentChunk.Data.Length); break; case PngChunkTypes.PALETTE: palette = currentChunk.Data; break; case PngChunkTypes.PALETTE_ALPHA: paletteAlpha = currentChunk.Data; break; case PngChunkTypes.END: endChunkReached = true; break; } } stream.Dispose(); // Determine color reader to use. PngColorTypeInformation colorTypeInformation = ColorTypes[fileHeader.ColorType]; if (colorTypeInformation == null) { return(null); } IColorReader colorReader = colorTypeInformation.CreateColorReader(palette, paletteAlpha); // Calculate the bytes per pixel. var bytesPerPixel = 1; if (fileHeader.BitDepth >= 8) { bytesPerPixel = colorTypeInformation.ChannelsPerColor * fileHeader.BitDepth / 8; } // Decompress data. dataStream.Position = 0; PerfProfiler.ProfilerEventStart("PNG Decompression", "Loading"); byte[] data = ZlibStreamUtility.Decompress(dataStream); PerfProfiler.ProfilerEventEnd("PNG Decompression", "Loading"); // Parse into pixels. var pixels = new byte[fileHeader.Width * fileHeader.Height * 4]; if (fileHeader.InterlaceMethod == 1) { ParseInterlaced(data, fileHeader, bytesPerPixel, colorReader, pixels); } else { Parse(data, fileHeader, bytesPerPixel, colorReader, pixels); } return(pixels); }
/// <summary> /// Decode the provided png file to a BGRA pixel array, Y flipped. /// </summary> /// <param name="pngData">The png file as bytes.</param> /// <param name="fileHeader">The png file's header.</param> /// <returns>The RGBA pixel data from the png.</returns> public static byte[] Decode(ReadOnlyMemory <byte> pngData, out PngFileHeader fileHeader) { fileHeader = new PngFileHeader(); if (!IsPng(pngData)) { Engine.Log.Warning("Tried to decode a non-png image!", MessageSource.ImagePng); return(null); } using var stream = new ByteReader(pngData); stream.Seek(8, SeekOrigin.Current); // Increment by header bytes. // Read chunks while there are valid chunks. var dataStream = new ReadOnlyLinkedMemoryStream(); PngChunk currentChunk; var endChunkReached = false; ReadOnlyMemory <byte> palette = null, paletteAlpha = null; int width = 0, height = 0; while ((currentChunk = new PngChunk(stream)).Valid) { if (endChunkReached) { Engine.Log.Warning("Image did not end with an end chunk...", MessageSource.ImagePng); continue; } switch (currentChunk.Type) { case PngChunkTypes.HEADER: { ByteReader chunkReader = currentChunk.ChunkReader; width = chunkReader.ReadInt32BE(); height = chunkReader.ReadInt32BE(); fileHeader.Size = new Vector2(width, height); fileHeader.BitDepth = chunkReader.ReadByte(); fileHeader.ColorType = chunkReader.ReadByte(); fileHeader.CompressionMethod = chunkReader.ReadByte(); fileHeader.FilterMethod = chunkReader.ReadByte(); fileHeader.InterlaceMethod = chunkReader.ReadByte(); break; } case PngChunkTypes.DATA: dataStream.AddMemory(currentChunk.ChunkReader.Data); break; case PngChunkTypes.PALETTE: palette = currentChunk.ChunkReader.Data; break; case PngChunkTypes.PALETTE_ALPHA: paletteAlpha = currentChunk.ChunkReader.Data; break; case PngChunkTypes.END: endChunkReached = true; break; } } // Decompress data. PerfProfiler.ProfilerEventStart("PNG Decompression", "Loading"); byte[] data = ZlibStreamUtility.Decompress(dataStream); PerfProfiler.ProfilerEventEnd("PNG Decompression", "Loading"); if (data == null) { return(null); } var channelsPerColor = 0; int bytesPerPixelOutput = 4; ColorReader reader; fileHeader.PixelFormat = PixelFormat.Bgra; // Default. switch (fileHeader.ColorType) { case 0: // Grayscale - No Alpha channelsPerColor = 1; bytesPerPixelOutput = 1; reader = Grayscale; fileHeader.PixelFormat = PixelFormat.Red; break; case 2: // RGB channelsPerColor = 3; reader = Rgb; break; case 3: // Palette channelsPerColor = 1; reader = (rowPixels, row, imageDest, destRow) => { Palette(palette.Span, paletteAlpha.Span, rowPixels, row, imageDest, destRow); }; break; case 4: // Grayscale - Alpha channelsPerColor = 2; reader = GrayscaleAlpha; break; case 6: // RGBA channelsPerColor = 4; reader = Rgba; fileHeader.PixelFormat = PixelFormat.Rgba; break; default: reader = null; break; } // Unknown color mode. if (reader == null) { Engine.Log.Warning($"Unsupported color type - {fileHeader.ColorType}", MessageSource.ImagePng); return(new byte[width * height * bytesPerPixelOutput]); } // Calculate the bytes per pixel. var bytesPerPixel = 1; if (fileHeader.BitDepth == 0 || fileHeader.BitDepth == 3) { Engine.Log.Warning("Invalid bit depth.", MessageSource.ImagePng); return(null); } if (fileHeader.BitDepth != 8) { Engine.Log.Warning("Loading PNGs with a bit depth different than 8 will be deprecated in future versions.", MessageSource.ImagePng); } if (fileHeader.BitDepth >= 8) { bytesPerPixel = channelsPerColor * fileHeader.BitDepth / 8; } // Check interlacing. if (fileHeader.InterlaceMethod == 1) { Engine.Log.Warning("Loading interlaced PNGs will be deprecated in future versions. Convert your images!", MessageSource.ImagePng); return(ParseInterlaced(data, fileHeader, bytesPerPixel, channelsPerColor, reader)); } int scanlineLength = GetScanlineLength(fileHeader, channelsPerColor) + 1; int scanLineCount = data.Length / scanlineLength; return(Parse(scanlineLength, scanLineCount, data, bytesPerPixel, fileHeader, reader, bytesPerPixelOutput)); }