GRAPHICS: Move PNG to the ImageDecoder interface

2 files changed, 638 insertions, 0 deletions

diff --git a/graphics/decoders/png.cpp b/graphics/decoders/png.cpp
new file mode 100644
index 0000000000..b87b6fdc7a
--- /dev/null
+++ b/graphics/decoders/png.cpp
@@ -0,0 +1,503 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "graphics/decoders/png.h"
+
+#include "graphics/pixelformat.h"
+#include "graphics/surface.h"
+
+#include "common/endian.h"
+#include "common/memstream.h"
+#include "common/stream.h"
+#include "common/types.h"
+#include "common/util.h"
+#include "common/zlib.h"
+
+// PNG decoder, based on the W3C specs:
+// http://www.w3.org/TR/PNG/
+// Parts of the code have been adapted from LodePNG, by Lode Vandevenne:
+// http://members.gamedev.net/lode/projects/LodePNG/
+
+/*
+LodePNG version 20101211
+
+Copyright (c) 2005-2010 Lode Vandevenne
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+*/
+
+namespace Graphics {
+
+enum PNGChunks {
+	// == Critical chunks =====================================================
+	kChunkIHDR = MKTAG('I','H','D','R'),	// Image header
+	kChunkIDAT = MKTAG('I','D','A','T'),	// Image data
+	kChunkPLTE = MKTAG('P','L','T','E'),	// Palette
+	kChunkIEND = MKTAG('I','E','N','D'),	// Image trailer
+	// == Ancillary chunks ====================================================
+	kChunktRNS = MKTAG('t','R','N','S')	// Transparency
+	// All of the other ancillary chunks are ignored. They're added here for
+	// reference only.
+	// cHRM - Primary chromacities and white point
+	// gAMA - Image gamma
+	// iCCP - Embedded ICC profile
+	// sBIT - Significant bits
+	// sRGB - Standard RGB color space
+	// tEXT - Textual data
+	// sTXt - Compressed textual data
+	// iTXt - International textual data
+	// bKGD - Background color
+	// hIST - Image histogram
+	// pHYs - Physical pixel dimensions
+	// sPLT - Suggested palette
+	// tIME - Image last-modification time
+};
+
+// Refer to http://www.w3.org/TR/PNG/#9Filters
+enum PNGFilters {
+	kFilterNone    = 0,
+	kFilterSub     = 1,
+	kFilterUp      = 2,
+	kFilterAverage = 3,
+	kFilterPaeth   = 4
+};
+
+PNGDecoder::PNGDecoder() : _compressedBuffer(0), _compressedBufferSize(0),
+			_transparentColorSpecified(false), _outputSurface(0) {
+}
+
+PNGDecoder::~PNGDecoder() {
+	destroy();
+}
+
+void PNGDecoder::destroy() {
+	if (_outputSurface) {
+		_outputSurface->free();
+		delete _outputSurface;
+		_outputSurface = 0;
+	}
+}
+
+bool PNGDecoder::loadStream(Common::SeekableReadStream &stream) {
+	destroy();
+
+	uint32 chunkLength = 0, chunkType = 0;
+	_stream = &stream;
+
+	// First, check the PNG signature
+	if (_stream->readUint32BE() != MKTAG(0x89, 'P', 'N', 'G')) {
+		delete _stream;
+		return false;
+	}
+	if (_stream->readUint32BE() != MKTAG(0x0d, 0x0a, 0x1a, 0x0a)) {
+		delete _stream;
+		return false;
+	}
+
+	// Start reading chunks till we reach an IEND chunk
+	while (chunkType != kChunkIEND) {
+		// The chunk length does not include the type or CRC bytes
+		chunkLength = _stream->readUint32BE();
+		chunkType = _stream->readUint32BE();
+
+		switch (chunkType) {
+		case kChunkIHDR:
+			readHeaderChunk();
+			break;
+		case kChunkIDAT:
+			if (_compressedBufferSize == 0) {
+				_compressedBufferSize += chunkLength;
+				_compressedBuffer = (byte *)malloc(_compressedBufferSize);
+				_stream->read(_compressedBuffer, chunkLength);
+			} else {
+				// Expand the buffer
+				uint32 prevSize = _compressedBufferSize;
+				_compressedBufferSize += chunkLength;
+				byte *tmp = new byte[prevSize];
+				memcpy(tmp, _compressedBuffer, prevSize);
+				free(_compressedBuffer);
+				_compressedBuffer = (byte *)malloc(_compressedBufferSize);
+				memcpy(_compressedBuffer, tmp, prevSize);
+				delete[] tmp;
+				_stream->read(_compressedBuffer + prevSize, chunkLength);
+			}
+			break;
+		case kChunkPLTE:	// only available in indexed PNGs
+			if (_header.colorType != kIndexed)
+				error("A palette chunk has been found in a non-indexed PNG file");
+			if (chunkLength % 3 != 0)
+				error("Palette chunk not divisible by 3");
+
+			_paletteEntries = chunkLength / 3;
+			_stream->read(_palette, _paletteEntries * 3);
+			memset(_paletteTransparency, 0xff, sizeof(_paletteTransparency));
+			break;
+		case kChunkIEND:
+			// End of stream
+			break;
+		case kChunktRNS:
+			readTransparencyChunk(chunkLength);
+			break;
+		default:
+			// Skip the chunk content
+			_stream->skip(chunkLength);
+			break;
+		}
+
+		if (chunkType != kChunkIEND)
+			_stream->skip(4);	// skip the chunk CRC checksum
+	}
+
+	// We no longer need the file stream, thus close it here
+	_stream = 0;
+
+	// Unpack the compressed buffer
+	Common::MemoryReadStream *compData = new Common::MemoryReadStream(_compressedBuffer, _compressedBufferSize, DisposeAfterUse::YES);
+	_imageData = Common::wrapCompressedReadStream(compData);
+
+	// Construct the final image
+	constructImage();
+
+	// Close the uncompressed stream, which will also delete the memory stream,
+	// and thus the original compressed buffer
+	delete _imageData;
+
+	return true;
+}
+
+/**
+ * Paeth predictor, used by PNG filter type 4
+ * The parameters are of signed 16-bit integers, but should come
+ * from unsigned chars. The integers  are only needed to make
+ * the paeth calculation correct.
+ *
+ * Taken from lodePNG, with a slight patch:
+ * http://www.atalasoft.com/cs/blogs/stevehawley/archive/2010/02/23/libpng-you-re-doing-it-wrong.aspx
+ */
+byte PNGDecoder::paethPredictor(int16 a, int16 b, int16 c) {
+  int16 pa = ABS<int16>(b - c);
+  int16 pb = ABS<int16>(a - c);
+  int16 pc = ABS<int16>(a + b - c - c);
+
+  if (pa <= MIN<int16>(pb, pc))
+	  return (byte)a;
+  else if (pb <= pc)
+	  return (byte)b;
+  else
+	  return (byte)c;
+}
+
+/**
+ * Unfilters a filtered PNG scan line.
+ * PNG filters are defined in: http://www.w3.org/TR/PNG/#9Filters
+ * Note that filters are always applied to bytes
+ *
+ * Taken from lodePNG
+ */
+void PNGDecoder::unfilterScanLine(byte *dest, const byte *scanLine, const byte *prevLine, uint16 byteWidth, byte filterType, uint16 length) {
+	uint16 i;
+
+	switch (filterType) {
+	case kFilterNone:		// no change
+		for (i = 0; i < length; i++)
+			dest[i] = scanLine[i];
+		break;
+	case kFilterSub:		// add the bytes to the left
+		for (i = 0; i < byteWidth; i++)
+			dest[i] = scanLine[i];
+		for (i = byteWidth; i < length; i++)
+			dest[i] = scanLine[i] + dest[i - byteWidth];
+		break;
+	case kFilterUp:			// add the bytes of the above scanline
+		if (prevLine) {
+			for (i = 0; i < length; i++)
+				dest[i] = scanLine[i] + prevLine[i];
+		} else {
+			for (i = 0; i < length; i++)
+				dest[i] = scanLine[i];
+		}
+		break;
+	case kFilterAverage:	// average value of the left and top left
+		if (prevLine) {
+			for (i = 0; i < byteWidth; i++)
+				dest[i] = scanLine[i] + prevLine[i] / 2;
+			for (i = byteWidth; i < length; i++)
+				dest[i] = scanLine[i] + ((dest[i - byteWidth] + prevLine[i]) / 2);
+		} else {
+			for (i = 0; i < byteWidth; i++)
+				dest[i] = scanLine[i];
+			for (i = byteWidth; i < length; i++)
+				dest[i] = scanLine[i] + dest[i - byteWidth] / 2;
+		}
+		break;
+	case kFilterPaeth:		// Paeth filter: http://www.w3.org/TR/PNG/#9Filter-type-4-Paeth
+		if (prevLine) {
+			for(i = 0; i < byteWidth; i++)
+				dest[i] = (scanLine[i] + prevLine[i]); // paethPredictor(0, prevLine[i], 0) is always prevLine[i]
+			for(i = byteWidth; i < length; i++)
+				dest[i] = (scanLine[i] + paethPredictor(dest[i - byteWidth], prevLine[i], prevLine[i - byteWidth]));
+		} else {
+			for(i = 0; i < byteWidth; i++)
+				dest[i] = scanLine[i];
+			for(i = byteWidth; i < length; i++)
+				dest[i] = (scanLine[i] + dest[i - byteWidth]); // paethPredictor(dest[i - byteWidth], 0, 0) is always dest[i - byteWidth]
+		}
+		break;
+	default:
+		error("Unknown line filter");
+	}
+
+}
+
+int PNGDecoder::getBytesPerPixel() const {
+	return (getNumColorChannels() * _header.bitDepth + 7) / 8;
+}
+
+void PNGDecoder::constructImage() {
+	assert (_header.bitDepth != 0);
+
+	int bytesPerPixel = getBytesPerPixel();
+	int pitch = bytesPerPixel * _header.width;
+	byte *unfilteredSurface = new byte[pitch * _header.height];
+	byte *dest = unfilteredSurface;
+	uint16 scanLineWidth = (_header.width * getNumColorChannels() * _header.bitDepth + 7) / 8;
+	byte *scanLine = new byte[scanLineWidth];
+	byte *prevLine = 0;
+
+	switch(_header.interlaceType) {
+	case kNonInterlaced:
+		for (uint16 y = 0; y < _header.height; y++) {
+			byte filterType = _imageData->readByte();
+			_imageData->read(scanLine, scanLineWidth);
+			unfilterScanLine(dest, scanLine, prevLine, bytesPerPixel, filterType, scanLineWidth);
+			prevLine = dest;
+			dest += pitch;
+		}
+		break;
+	case kInterlaced:
+		// Theoretically, this shouldn't be needed, as interlacing is only
+		// useful for web images. Interlaced PNG images require more complex
+		// handling, so unless having support for such images is needed, there
+		// is no reason to add support for them.
+		error("TODO: Support for interlaced PNG images");
+		break;
+	}
+
+	delete[] scanLine;
+
+	constructOutput(unfilteredSurface);
+	delete[] unfilteredSurface;
+}
+
+Graphics::PixelFormat PNGDecoder::findPixelFormat() const {
+	// Try to find the best pixel format based on what we have here
+	// Which is basically 8bpp for paletted non-transparent
+	// and 32bpp for everything else
+
+	switch (_header.colorType) {
+	case kIndexed:
+		if (!_transparentColorSpecified)
+			return Graphics::PixelFormat::createFormatCLUT8();
+		// fall through
+	case kGrayScale:
+	case kTrueColor:
+	case kGrayScaleWithAlpha:
+	case kTrueColorWithAlpha:
+		// We'll go with standard RGBA 32-bit
+		return Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0);
+	}
+
+	error("Unknown PNG color type");
+	return Graphics::PixelFormat();
+}
+
+void PNGDecoder::constructOutput(const byte *surface) {
+	_outputSurface = new Graphics::Surface();
+	_outputSurface->create(_header.width, _header.height, findPixelFormat());
+
+	const byte *src = surface;
+	byte a = 0xFF;
+	int bytesPerPixel = getBytesPerPixel();
+
+	if (_header.colorType != kIndexed) {
+		if (_header.colorType == kTrueColor || 
+			_header.colorType == kTrueColorWithAlpha) {
+			if (bytesPerPixel != 3 && bytesPerPixel != 4)
+				error("Unsupported truecolor PNG format");
+		} else if (_header.colorType == kGrayScale ||
+				   _header.colorType == kGrayScaleWithAlpha) {
+			if (bytesPerPixel != 1 && bytesPerPixel != 2)
+				error("Unsupported grayscale PNG format");
+		}
+
+		for (uint16 i = 0; i < _outputSurface->h; i++) {
+			for (uint16 j = 0; j < _outputSurface->w; j++) {
+				uint32 result = 0;
+
+				switch (bytesPerPixel) {
+				case 1:	// Grayscale
+					if (_transparentColorSpecified)
+						a = (src[0] == _transparentColor[0]) ? 0 : 0xFF;
+					result = _outputSurface->format.ARGBToColor(a, src[0], src[0], src[0]);
+					break;
+				case 2: // Grayscale + alpha
+					result = _outputSurface->format.ARGBToColor(src[1], src[0], src[0], src[0]);
+					break;
+				case 3: // RGB
+					if (_transparentColorSpecified) {
+						bool isTransparentColor = (src[0] == _transparentColor[0] &&
+												   src[1] == _transparentColor[1] &&
+												   src[2] == _transparentColor[2]);
+						a = isTransparentColor ? 0 : 0xFF;
+					}
+
+					result = _outputSurface->format.ARGBToColor(a, src[0], src[1], src[2]);
+					break;
+				case 4: // RGBA
+					result = _outputSurface->format.ARGBToColor(src[3], src[0], src[1], src[2]);
+					break;
+				}
+
+				*((uint32 *)_outputSurface->getBasePtr(j, i)) = result;
+				src += bytesPerPixel;
+			}
+		}
+	} else {
+		uint32 mask = (0xff >> (8 - _header.bitDepth)) << (8 - _header.bitDepth);
+
+		// Convert the indexed surface to the target pixel format
+		for (uint16 i = 0; i < _outputSurface->h; i++) {
+			int data = 0;
+			int bitCount = 8;
+			const byte *src1 = src;
+
+			for (uint16 j = 0; j < _outputSurface->w; j++) {
+				if (bitCount == 8) {
+					data = *src;
+					src++;
+				}
+
+				byte index = (data & mask) >> (8 - _header.bitDepth);
+				data = (data << _header.bitDepth) & 0xff;
+				bitCount -= _header.bitDepth;
+
+				if (bitCount == 0)
+					bitCount = 8;
+
+				if (_transparentColorSpecified) {
+					byte r = _palette[index * 3 + 0];
+					byte g = _palette[index * 3 + 1];
+					byte b = _palette[index * 3 + 2];
+					a = _paletteTransparency[index];
+					*((uint32 *)_outputSurface->getBasePtr(j, i)) = _outputSurface->format.ARGBToColor(a, r, g, b);
+				} else {
+					*((byte *)_outputSurface->getBasePtr(j, i)) = index;
+				}
+			}
+
+			src = src1 + _outputSurface->w;
+		}
+	}
+}
+
+void PNGDecoder::readHeaderChunk() {
+	_header.width = _stream->readUint32BE();
+	_header.height = _stream->readUint32BE();
+	_header.bitDepth = _stream->readByte();
+	if (_header.bitDepth > 8)
+		error("Only PNGs with a bit depth of 1-8 bits are supported (i.e. PNG24)");
+	_header.colorType = (PNGColorType)_stream->readByte();
+	_header.compressionMethod = _stream->readByte();
+	// Compression methods: http://www.w3.org/TR/PNG/#10Compression
+	// Only compression method 0 (deflate) is documented and supported
+	if (_header.compressionMethod != 0)
+		error("Unknown PNG compression method: %d", _header.compressionMethod);
+	_header.filterMethod = _stream->readByte();
+	// Filter methods: http://www.w3.org/TR/PNG/#9Filters
+	// Only filter method 0 is documented and supported
+	if (_header.filterMethod != 0)
+		error("Unknown PNG filter method: %d", _header.filterMethod);
+	_header.interlaceType = (PNGInterlaceType)_stream->readByte();
+}
+
+byte PNGDecoder::getNumColorChannels() const {
+	switch (_header.colorType) {
+	case kGrayScale:
+		return 1; // Gray
+	case kTrueColor:
+		return 3; // RGB
+	case kIndexed:
+		return 1; // Indexed
+	case kGrayScaleWithAlpha:
+		return 2; // Gray + Alpha
+	case kTrueColorWithAlpha:
+		return 4; // RGBA
+	default:
+		error("Unknown color type");
+	}
+}
+
+void PNGDecoder::readTransparencyChunk(uint32 chunkLength) {
+	_transparentColorSpecified = true;
+
+	switch(_header.colorType) {
+	case kGrayScale:
+		_transparentColor[0] = _stream->readUint16BE();
+		_transparentColor[1] = _transparentColor[0];
+		_transparentColor[2] = _transparentColor[0];
+		break;
+	case kTrueColor:
+		_transparentColor[0] = _stream->readUint16BE();
+		_transparentColor[1] = _stream->readUint16BE();
+		_transparentColor[2] = _stream->readUint16BE();
+		break;
+	case kIndexed:
+		_stream->read(_paletteTransparency, chunkLength);
+
+		// A transparency chunk may have less entries
+		// than the palette entries. The remaining ones
+		// are unmodified (set to 255). Check here:
+		// http://www.w3.org/TR/PNG/#11tRNS
+		break;
+	default:
+		error("Transparency chunk found in a PNG that has a separate transparency channel");
+	}
+}
+
+} // End of Graphics namespace
diff --git a/graphics/decoders/png.h b/graphics/decoders/png.h
new file mode 100644
index 0000000000..1da0bea1ab
--- /dev/null
+++ b/graphics/decoders/png.h
@@ -0,0 +1,135 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/*
+ * PNG decoder used in engines:
+ *  - sword25
+ * Dependencies:
+ *  - zlib
+ */
+
+#ifndef GRAPHICS_PNG_H
+#define GRAPHICS_PNG_H
+
+// PNG decoder, based on the W3C specs:
+// http://www.w3.org/TR/PNG/
+// Parts of the code have been adapted from LodePNG, by Lode Vandevenne:
+// http://members.gamedev.net/lode/projects/LodePNG/
+
+// All the numbers are BE: http://www.w3.org/TR/PNG/#7Integers-and-byte-order
+
+// Note: At the moment, this decoder only supports non-interlaced images, and
+// does not support truecolor/grayscale images with 16bit depth.
+//
+// Theoretically, interlaced images shouldn't be needed for games, as
+// interlacing is only useful for images in websites.
+//
+// PNG images with 16bit depth (i.e. 48bit images) are quite rare, and can
+// theoretically contain more than 16.7 millions of colors (the so-called "deep
+// color" representation). In essence, each of the R, G, B and A components in
+// them is specified with 2 bytes, instead of 1. However, the PNG specification
+// always refers to color components with 1 byte each, so this part of the spec
+// is a bit unclear. For now, these won't be supported, until a suitable sample
+// is found.
+
+#include "common/scummsys.h"
+#include "common/textconsole.h"
+#include "graphics/decoders/image_decoder.h"
+
+namespace Common {
+class SeekableReadStream;
+}
+
+namespace Graphics {
+
+struct Surface;
+struct PixelFormat;
+
+class PNGDecoder : public ImageDecoder {
+public:
+	PNGDecoder();
+	~PNGDecoder();
+
+	bool loadStream(Common::SeekableReadStream &stream);
+	void destroy();
+	const Graphics::Surface *getSurface() const { return _outputSurface; }
+	const byte *getPalette() const { return _palette; }
+
+private:
+	enum PNGColorType {
+		kGrayScale          = 0,	// bit depths: 1, 2, 4, 8, 16
+		kTrueColor          = 2,	// bit depths: 8, 16
+		kIndexed            = 3,	// bit depths: 1, 2, 4, 8
+		kGrayScaleWithAlpha = 4,	// bit depths: 8, 16
+		kTrueColorWithAlpha = 6		// bit depths: 8, 16
+	};
+
+	enum PNGInterlaceType {
+		kNonInterlaced      = 0,
+		kInterlaced         = 1
+	};
+
+	struct PNGHeader {
+		uint32 width;
+		uint32 height;
+		byte bitDepth;
+		PNGColorType colorType;
+		byte compressionMethod;
+		byte filterMethod;
+		PNGInterlaceType interlaceType;
+	};
+
+	void readHeaderChunk();
+	byte getNumColorChannels() const;
+
+	void readPaletteChunk();
+	void readTransparencyChunk(uint32 chunkLength);
+
+	void constructImage();
+	void unfilterScanLine(byte *dest, const byte *scanLine, const byte *prevLine, uint16 byteWidth, byte filterType, uint16 length);
+	byte paethPredictor(int16 a, int16 b, int16 c);
+
+	// The original file stream
+	Common::SeekableReadStream *_stream;
+	// The unzipped image data stream
+	Common::SeekableReadStream *_imageData;
+
+	PNGHeader _header;
+
+	byte _palette[256 * 3];	// RGB
+	byte _paletteTransparency[256];
+	uint16 _paletteEntries;
+	uint16 _transparentColor[3];
+	bool _transparentColorSpecified;
+
+	byte *_compressedBuffer;
+	uint32 _compressedBufferSize;
+
+	Graphics::Surface *_outputSurface;
+	Graphics::PixelFormat findPixelFormat() const;
+	int getBytesPerPixel() const;
+	void constructOutput(const byte *surface);
+};
+
+} // End of namespace Graphics
+
+#endif // GRAPHICS_PNG_H