path: root/engines/sword25/gfx/image/pngloader.cpp

/* 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.
 *
 * $URL$
 * $Id$
 *
 */

/* 
 * This code is based on Broken Sword 2.5 engine
 *
 * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
 *
 * Licensed under GNU GPL v2
 *
 */

// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------

#include "sword25/gfx/image/image.h"
#include "sword25/gfx/image/pngloader.h"
#include <png.h>

namespace Sword25 {

#define BS_LOG_PREFIX "PNGLOADER"

// -----------------------------------------------------------------------------
// Konstruktor / Destruktor
// -----------------------------------------------------------------------------

BS_PNGLoader::BS_PNGLoader()
{
}

// -----------------------------------------------------------------------------
// Laden
// -----------------------------------------------------------------------------

static void png_user_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
	memcpy(data, (char*)png_ptr->io_ptr, length);
	png_ptr->io_ptr = (void*)((png_size_t)png_ptr->io_ptr + length);
}

// -----------------------------------------------------------------------------

bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
								 int & Width, int & Height, int & Pitch)
{
	png_structp png_ptr = NULL;
	png_infop   info_ptr = NULL;
	png_bytep	RawDataBuffer = NULL;
	png_bytep*	pRowPtr = NULL;

	int			BitDepth;
	int			ColorType;
	int			InterlaceType;
	int			i;

	// Zielfarbformat �berpr�fen
	if (ColorFormat != BS_GraphicEngine::CF_RGB16 &&
		ColorFormat != BS_GraphicEngine::CF_RGB15 &&
		ColorFormat != BS_GraphicEngine::CF_RGB16_INTERLEAVED &&
		ColorFormat != BS_GraphicEngine::CF_RGB15_INTERLEAVED &&
		ColorFormat != BS_GraphicEngine::CF_ARGB32 &&
		ColorFormat != BS_GraphicEngine::CF_ABGR32)
	{
		BS_LOG_ERRORLN("Illegal or unsupported color format.");
		return false;
	}

	try
	{
		// PNG Signatur �berpr�fen
		if (!png_check_sig(reinterpret_cast<png_bytep>(const_cast<char *>(FileDataPtr)), 8))
		{
			throw(0);
		}

		// Die beiden PNG Strukturen erstellen
		png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
		if (!png_ptr)
		{
			BS_LOG_ERRORLN("Could not create libpng read struct.");
			throw(0);
		}

		info_ptr = png_create_info_struct(png_ptr);
		if (!info_ptr)
		{
			BS_LOG_ERRORLN("Could not create libpng info struct.");
			throw(0);
		}

		// R�cksprungpunkt setzen. Wird im Falle eines Fehlers angesprungen.
		if (setjmp(png_jmpbuf(png_ptr))) throw(0);

		// Alternative Lesefunktion benutzen
		png_set_read_fn(png_ptr, (void*)FileDataPtr, png_user_read_data);

		// PNG Header einlesen
		png_read_info(png_ptr, info_ptr);

		// PNG Informationen auslesen
		png_get_IHDR(png_ptr, info_ptr, (unsigned long*)&Width, (unsigned long*)&Height, &BitDepth, &ColorType, &InterlaceType, NULL, NULL);

		// Pitch des Ausgabebildes berechnen
		Pitch = BS_GraphicEngine::CalcPitch(ColorFormat, Width);

		// Speicher f�r die endg�ltigen Bilddaten reservieren
		// Dieses geschieht vor dem reservieren von Speicher f�r tempor�re Bilddaten um die Fragmentierung des Speichers gering zu halten
		UncompressedDataPtr = new char[Pitch * Height];
		if (!UncompressedDataPtr)
		{
			BS_LOG_ERRORLN("Could not allocate memory for output image.");
			throw(0);
		}

		// Bilder jeglicher Farbformate werden zun�chst in ARGB Bilder umgewandelt
		if (BitDepth == 16)
			png_set_strip_16(png_ptr);
		if (ColorType == PNG_COLOR_TYPE_PALETTE)
			png_set_expand(png_ptr);
		if (BitDepth < 8)
			png_set_expand(png_ptr);
		if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
			png_set_expand(png_ptr);
		if (ColorType == PNG_COLOR_TYPE_GRAY ||
			ColorType == PNG_COLOR_TYPE_GRAY_ALPHA)
			png_set_gray_to_rgb(png_ptr);

		png_set_bgr(png_ptr);

		if (ColorType != PNG_COLOR_TYPE_RGB_ALPHA)
			png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);

		// Nachdem die Transformationen registriert wurden, werden die Bilddaten erneut eingelesen
		png_read_update_info(png_ptr, info_ptr);
		png_get_IHDR(png_ptr, info_ptr, (unsigned long*)&Width, (unsigned long*)&Height, &BitDepth, &ColorType, NULL, NULL, NULL);

		// PNGs ohne Interlacing werden Zeilenweise eingelesen
		if (InterlaceType == PNG_INTERLACE_NONE)
		{
			// Speicher f�r eine Bildzeile reservieren
			RawDataBuffer = new png_byte[png_get_rowbytes(png_ptr, info_ptr)];
			if (!RawDataBuffer)
			{
				BS_LOG_ERRORLN("Could not allocate memory for row buffer.");
				throw(0);
			}

			// Bilddaten zeilenweise einlesen und in das gew�nschte Zielformat konvertieren
			for (i = 0; i < Height; i++)
			{
				// Zeile einlesen
				png_read_row(png_ptr, RawDataBuffer, NULL);

				// Zeile konvertieren
				switch (ColorFormat)
				{
				case BS_GraphicEngine::CF_RGB16:
					RowARGB32ToRGB16((unsigned char*)RawDataBuffer,
						(unsigned char*)&UncompressedDataPtr[i * Pitch],
						Width);
					break;

				case BS_GraphicEngine::CF_RGB15:
					RowARGB32ToRGB15((unsigned char*)RawDataBuffer,
						(unsigned char*)&UncompressedDataPtr[i * Pitch],
						Width);
					break;

				case BS_GraphicEngine::CF_RGB16_INTERLEAVED:
					RowARGB32ToRGB16_INTERLEAVED((unsigned char*)RawDataBuffer,
						(unsigned char*)&UncompressedDataPtr[i * Pitch],
						Width);
					break;

				case BS_GraphicEngine::CF_RGB15_INTERLEAVED:
					RowARGB32ToRGB15_INTERLEAVED((unsigned char*)RawDataBuffer,
						(unsigned char*)&UncompressedDataPtr[i * Pitch],
						Width);
					break;

				case BS_GraphicEngine::CF_ARGB32:
					memcpy(&UncompressedDataPtr[i * Pitch],
						RawDataBuffer,
						Pitch);
					break;

				case BS_GraphicEngine::CF_ABGR32:
					RowARGB32ToABGR32((unsigned char*)RawDataBuffer,
						(unsigned char*)&UncompressedDataPtr[i * Pitch],
						Width);
					break;

				default:
					BS_ASSERT(false);
				}
			}
		}
		// PNGs mit Interlacing werden an einem St�ck eingelesen
		else
		{
			// Speicher f�r das komplette Bild reservieren
			RawDataBuffer = new png_byte[png_get_rowbytes(png_ptr, info_ptr) * Height];
			if (!RawDataBuffer)
			{
				BS_LOG_ERRORLN("Could not allocate memory for raw image buffer.");
				throw(0);
			}

			// Speicher f�r die Rowpointer reservieren
			pRowPtr = new png_bytep[Height];
			if (!pRowPtr)
			{
				BS_LOG_ERRORLN("Could not allocate memory for row pointers.");
				throw(0);
			}

			// Alle Rowpointer mit den richtigen Offsets initialisieren
			for (i = 0; i < Height; i++)
				pRowPtr[i] = RawDataBuffer + i * png_get_rowbytes(png_ptr, info_ptr);

			// Bild einlesen
			png_read_image(png_ptr, pRowPtr);

			// Bilddaten zeilenweise in das gew�nschte Ausgabeformat konvertieren
			switch (ColorFormat)
			{
			case BS_GraphicEngine::CF_RGB16:
				for (i = 0; i < Height; i++)
					RowARGB32ToRGB16((unsigned char*)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
					(unsigned char*)&UncompressedDataPtr[i * Pitch],
					Width);
				break;

			case BS_GraphicEngine::CF_RGB15:
				for (i = 0; i < Height; i++)
					RowARGB32ToRGB15((unsigned char*)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
					(unsigned char*)&UncompressedDataPtr[i * Pitch],
					Width);
				break;

			case BS_GraphicEngine::CF_RGB16_INTERLEAVED:
				for (i = 0; i < Height; i++)
					RowARGB32ToRGB16_INTERLEAVED((unsigned char*)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
					(unsigned char*)&UncompressedDataPtr[i * Pitch],
					Width);
				break;

			case BS_GraphicEngine::CF_RGB15_INTERLEAVED:
				for (i = 0; i < Height; i++)
					RowARGB32ToRGB15_INTERLEAVED((unsigned char*)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
					(unsigned char*)&UncompressedDataPtr[i * Pitch],
					Width);
				break;

			case BS_GraphicEngine::CF_ARGB32:
				for (i = 0; i < Height; i++)
					memcpy(&UncompressedDataPtr[i * Pitch],
					&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)],
					Pitch);
				break;
			}
		}

		// Die zus�tzlichen Daten am Ende des Bildes lesen
		png_read_end(png_ptr, NULL);

		// Die Strukturen freigeben
		png_destroy_read_struct(&png_ptr, &info_ptr, NULL);

		// Tempor�re Buffer freigeben
		delete[] pRowPtr;
		delete[] RawDataBuffer;
	}

	catch(int)
	{
		delete[] pRowPtr;
		delete[] RawDataBuffer;
		if (png_ptr) png_destroy_read_struct(&png_ptr, NULL, NULL);
		if (info_ptr) png_destroy_read_struct(NULL, &info_ptr, NULL);

		// Der Funktionsaufruf war nicht erfolgreich
		return false;
	}

	// Der Funktionsaufruf war erfolgreich
	return true;
}

// -----------------------------------------------------------------------------

bool BS_PNGLoader::DecodeImage(const char * FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
							   int & Width, int & Height, int & Pitch)
{
	return DoDecodeImage(FileDataPtr, FileSize, ColorFormat, UncompressedDataPtr, Width, Height, Pitch);
}

// -----------------------------------------------------------------------------

bool BS_PNGLoader::DoImageProperties(const char * FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS & ColorFormat, int & Width, int & Height)
{
	// PNG Signatur �berpr�fen
	if (!DoIsCorrectImageFormat(FileDataPtr, FileSize)) return false;

	png_structp png_ptr = NULL;
	png_infop info_ptr = NULL;
	try
	{
		// Die beiden PNG Strukturen erstellen
		png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
		if (!png_ptr)
		{
			BS_LOG_ERRORLN("Could not create libpng read struct.");
			throw(0);
		}

		info_ptr = png_create_info_struct(png_ptr);
		if (!info_ptr)
		{
			BS_LOG_ERRORLN("Could not create libpng info struct.");
			throw(0);
		}

		// Alternative Lesefunktion benutzen
		png_set_read_fn(png_ptr, (void*)FileDataPtr, png_user_read_data);

		// PNG Header einlesen
		png_read_info(png_ptr, info_ptr);

		// PNG Informationen auslesen
		int BitDepth;
		int ColorType;
		png_get_IHDR(png_ptr, info_ptr, (unsigned long*)&Width, (unsigned long*)&Height, &BitDepth, &ColorType, NULL, NULL, NULL);

		// PNG-ColorType in BS ColorFormat konvertieren.
		if (ColorType & PNG_COLOR_MASK_ALPHA || png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
			ColorFormat = BS_GraphicEngine::CF_ARGB32;
		else
			ColorFormat = BS_GraphicEngine::CF_RGB24;

		// Die Strukturen freigeben
		png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
	}

	catch (int)
	{
		if (png_ptr) png_destroy_read_struct(&png_ptr, NULL, NULL);
		if (info_ptr) png_destroy_read_struct(NULL, &info_ptr, NULL);

		// Der Funktionsaufruf war nicht erfolgreich
		return false;
	}

	return true;

}

// -----------------------------------------------------------------------------

bool BS_PNGLoader::ImageProperties(const char* FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS & ColorFormat, int & Width, int & Height)
{
	return DoImageProperties(FileDataPtr, FileSize, ColorFormat, Width, Height);
}

// -----------------------------------------------------------------------------
// Header �berpr�fen
// -----------------------------------------------------------------------------

bool BS_PNGLoader::DoIsCorrectImageFormat(const char * FileDataPtr, unsigned int FileSize)
{
	if (FileSize > 8)
		return png_check_sig((unsigned char*)FileDataPtr, 8) ? true : false;
	else
		return false;
}

// -----------------------------------------------------------------------------

bool BS_PNGLoader::IsCorrectImageFormat(const char* FileDataPtr, unsigned int FileSize)
{
	return DoIsCorrectImageFormat(FileDataPtr, FileSize);
}

} // End of namespace Sword25