SWORD25: Further savegame work, including savegame screenshots

This handles saving (but not yet re-loaded display) of screenshots into savegame files. It also changes the original engine behaviour of temporarily saving the screenshots in a file 'tmp.png' to keeping the raw PNG file data in a memory block.

svn-id: r53373

4 files changed, 145 insertions, 190 deletions

diff --git a/engines/sword25/gfx/graphicengine.cpp b/engines/sword25/gfx/graphicengine.cpp
index b0e1b17359..fe19dc7df5 100644
--- a/engines/sword25/gfx/graphicengine.cpp
+++ b/engines/sword25/gfx/graphicengine.cpp
@@ -88,6 +88,7 @@ GraphicEngine::GraphicEngine(Kernel *pKernel) :
 	m_TimerActive(true),
 	m_FrameTimeSampleSlot(0),
 	m_RepaintedPixels(0),
+	_thumbnail(NULL),
 	ResourceService(pKernel) {
 	m_FrameTimeSamples.resize(FRAMETIME_SAMPLE_COUNT);
 
@@ -99,6 +100,8 @@ GraphicEngine::GraphicEngine(Kernel *pKernel) :
 
 GraphicEngine::~GraphicEngine() {
 	_backSurface.free();
+	_frameBuffer.free();
+	delete _thumbnail;
 }
 
 Service *GraphicEngine_CreateObject(Kernel *pKernel) {
@@ -129,6 +132,7 @@ bool GraphicEngine::Init(int Width, int Height, int BitDepth, int BackbufferCoun
 	m_ScreenRect.bottom = m_Height;
 
 	_backSurface.create(Width, Height, 4);
+	_frameBuffer.create(Width, Height, 4);
 
 	// Standardmäßig ist Vsync an.
 	SetVsync(true);
@@ -163,6 +167,15 @@ bool GraphicEngine::EndFrame() {
 	// Scene zeichnen
 	_renderObjectManagerPtr->render();
 
+	// FIXME: The frame buffer surface is only used as the base for creating thumbnails when saving the
+	// game, since the _backSurface is blanked. Currently I'm doing a slightly hacky check and only
+	// copying the back surface if line 50 (the first line after the interface area) is non-blank
+	if (READ_LE_UINT32((byte *)_backSurface.pixels + (_backSurface.pitch * 50)) & 0xffffff) {
+		// Make a copy of the current frame into the frame buffer
+		Common::copy((byte *)_backSurface.pixels, (byte *)_backSurface.pixels + 
+			(_backSurface.pitch * _backSurface.h), (byte *)_frameBuffer.pixels); 
+	}
+
 	g_system->updateScreen();
 
 	// Debug-Lines zeichnen
@@ -236,55 +249,8 @@ bool GraphicEngine::fill(const Common::Rect *fillRectPtr, uint color) {
 
 // -----------------------------------------------------------------------------
 
-bool GraphicEngine::GetScreenshot(uint &Width, uint &Height, byte **Data) {
-	if (!ReadFramebufferContents(m_Width, m_Height, Data))
-		return false;
-
-	// Die Größe des Framebuffers zurückgeben.
-	Width = m_Width;
-	Height = m_Height;
-
-	// Bilddaten vom OpenGL-Format in unser eigenes Format umwandeln.
-	ReverseRGBAComponentOrder(*Data, Width * Height);
-	FlipImagedataVertical(Width, Height, *Data);
-
-	return true;
-}
-
-// -----------------------------------------------------------------------------
-
-bool GraphicEngine::ReadFramebufferContents(uint Width, uint Height, byte **Data) {
-    *Data = (byte *)malloc(Width * Height * 4);
-	
-	return true;
-}
-
-// -----------------------------------------------------------------------------
-
-void GraphicEngine::ReverseRGBAComponentOrder(byte *Data, uint size) {
-	uint32 *ptr = (uint32 *)Data;
-
-	for (uint i = 0; i < size; i++) {
-		uint Pixel = *ptr;
-		*ptr = (Pixel & 0xff00ff00) | ((Pixel >> 16) & 0xff) | ((Pixel & 0xff) << 16);
-		++ptr;
-	}
-}
-
-// -----------------------------------------------------------------------------
-
-void GraphicEngine::FlipImagedataVertical(uint Width, uint Height, byte *Data) {
-#if 0 // TODO
-	vector<uint> LineBuffer(Width);
-
-	for (uint Y = 0; Y < Height / 2; ++Y) {
-		vector<uint>::iterator Line1It = Data.begin() + Y * Width;
-		vector<uint>::iterator Line2It = Data.begin() + (Height - 1 - Y) * Width;
-		copy(Line1It, Line1It + Width, LineBuffer.begin());
-		copy(Line2It, Line2It + Width, Line1It);
-		copy(LineBuffer.begin(), LineBuffer.end(), Line2It);
-	}
-#endif
+Graphics::Surface *GraphicEngine::GetScreenshot() {
+	return &_frameBuffer;
 }
 
 // -----------------------------------------------------------------------------
@@ -432,28 +398,37 @@ void  GraphicEngine::UpdateLastFrameDuration() {
 }
 
 namespace {
-bool DoSaveScreenshot(GraphicEngine &GraphicEngine, const Common::String &Filename, bool Thumbnail) {
-	uint Width;
-	uint Height;
-	byte *Data;
-	if (!GraphicEngine.GetScreenshot(Width, Height, &Data)) {
+bool DoSaveScreenshot(GraphicEngine &GraphicEngine, const Common::String &Filename) {
+	Graphics::Surface *data = GraphicEngine.GetScreenshot();
+	if (!data) {
 		BS_LOG_ERRORLN("Call to GetScreenshot() failed. Cannot save screenshot.");
 		return false;
 	}
 
-	if (Thumbnail)
-		return Screenshot::SaveThumbnailToFile(Width, Height, Data, Filename);
-	else
-		return Screenshot::SaveToFile(Width, Height, Data, Filename);
+	Common::FSNode f(Filename);
+	Common::WriteStream *stream = f.createWriteStream();
+	if (!stream) {
+		BS_LOG_ERRORLN("Call to GetScreenshot() failed. Cannot save screenshot.");
+		return false;
+	}
+
+	bool result = Screenshot::SaveToFile(data, stream);
+	delete stream;
+
+	return result;
 }
 }
 
 bool GraphicEngine::SaveScreenshot(const Common::String &Filename) {
-	return DoSaveScreenshot(*this, Filename, false);
+	return DoSaveScreenshot(*this, Filename);
 }
 
 bool GraphicEngine::SaveThumbnailScreenshot(const Common::String &Filename) {
-	return DoSaveScreenshot(*this, Filename, true);
+	// Note: In ScumMVM, rather than saivng the thumbnail to a file, we store it in memory 
+	// until needed when creating savegame files
+	delete _thumbnail;
+	_thumbnail = Screenshot::createThumbnail(&_frameBuffer);
+	return true;
 }
 
 void GraphicEngine::ARGBColorToLuaColor(lua_State *L, uint Color) {
diff --git a/engines/sword25/gfx/graphicengine.h b/engines/sword25/gfx/graphicengine.h
index 8c98d349fd..5e9a08cb54 100644
--- a/engines/sword25/gfx/graphicengine.h
+++ b/engines/sword25/gfx/graphicengine.h
@@ -181,7 +181,7 @@ public:
 	 * @param Height    Returns the height of the frame buffer
 	 * @param Data      Returns the raw data of the frame buffer as an array of 32-bit colour values.
 	*/
-	bool GetScreenshot(uint &Width, uint &Height, byte **Data);
+	Graphics::Surface *GetScreenshot();
 
 
 	RenderObjectPtr<Panel> GetMainPanel();
@@ -285,6 +285,12 @@ public:
 	Graphics::Surface _backSurface;
 	Graphics::Surface *getSurface() { return &_backSurface; }
 
+	Graphics::Surface _frameBuffer;
+	Graphics::Surface *getFrameBuffer() { return &_frameBuffer; }
+
+	Common::MemoryReadStream *_thumbnail;
+	Common::MemoryReadStream *getThumbnail() { return _thumbnail; }
+
 	// Access methods
 
 	/**
@@ -385,10 +391,6 @@ private:
 	};
 
 	Common::Array<DebugLine> m_DebugLines;
-
-	static bool ReadFramebufferContents(uint Width, uint Height, byte **Data);
-	static void ReverseRGBAComponentOrder(byte *Data, uint size);
-	static void FlipImagedataVertical(uint Width, uint Height, byte *Data);
 };
 
 } // End of namespace Sword25
diff --git a/engines/sword25/gfx/screenshot.cpp b/engines/sword25/gfx/screenshot.cpp
index ce1f98797c..9eea2ec422 100644
--- a/engines/sword25/gfx/screenshot.cpp
+++ b/engines/sword25/gfx/screenshot.cpp
@@ -38,175 +38,152 @@
 // Includes
 // -----------------------------------------------------------------------------
 
+#include "common/system.h"
+#include "common/savefile.h"
 #include "sword25/gfx/screenshot.h"
+#include "sword25/kernel/filesystemutil.h"
 #include <png.h>
 
 namespace Sword25 {
 
 // -----------------------------------------------------------------------------
 
+#include "common/pack-start.h"
 struct RGB_PIXEL {
-	RGB_PIXEL(byte _Red, byte _Green, byte _Blue) :
-		Red(_Red),
-		Green(_Green),
-		Blue(_Blue)
-	{};
-
 	byte Red;
 	byte Green;
 	byte Blue;
-};
-
-bool Screenshot::SaveToFile(uint Width, uint Height, const byte *Data, const Common::String &Filename) {
-#if 0
-	BS_ASSERT(Data.size() == Width * Height);
-
-	// Buffer für Bildschirminhalt in RGB reservieren
-	vector<RGB_PIXEL> PixelBuffer;
-	PixelBuffer.reserve(Width * Height);
-
-	// Framebufferdaten pixelweise von RGBA nach RGB konvertieren
-	vector<uint>::const_iterator it = Data.begin();
-	for (uint y = 0; y < Height; y++) {
-		for (uint x = 0; x < Width; x++) {
-			uint SrcPixel = *it++;
-			PixelBuffer.push_back(RGB_PIXEL((SrcPixel >> 16) & 0xff, (SrcPixel >> 8) & 0xff, SrcPixel & 0xff));
-		}
-	}
-	BS_ASSERT(it == Data.end());
-	BS_ASSERT(Data.size() == PixelBuffer.size());
-
-	// Variablen für die PNG-Erstellung
-	FILE *OutFile = 0;
-	png_structp png_ptr = 0;
-	png_infop info_ptr = 0;
-
-	try {
-		OutFile = fopen(Filename.c_str(), "wb");
-		if (!OutFile) {
-			BS_LOG_ERRORLN("Could not create screenshot-file \"%s\".", Filename.c_str());
-			throw(0);
-		}
+} PACKED_STRUCT;
+#include "common/pack-end.h"
 
-		png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-		if (!png_ptr) {
-			BS_LOG_ERRORLN("Could not create PNG write-struct.");
-			throw(0);
-		}
+void userWriteFn(png_structp png_ptr, png_bytep data, png_size_t length) {
+	static_cast<Common::WriteStream *>(png_ptr->io_ptr)->write(data, length);
+}
 
-		png_infop info_ptr = png_create_info_struct(png_ptr);
-		if (!info_ptr) {
-			BS_LOG_ERRORLN("Could not create PNG info-struct.");
-			throw(0);
-		}
+void userFlushFn(png_structp png_ptr) {
+}
 
-		// Der Kompressionsbuffer muss groß genug sein um das gesamte Bild zu beinhalten.
-		// Dieses stellt sicher, dass nur ein IDAT Chunk erstellt wird.
-		// Als Buffergröße wird 110% der Rohdatengröße verwandt, um sicher zu gehen.
-		png_set_compression_buffer_size(png_ptr, (Width * Height * 3 * 110) / 100);
-
-		// PNG-Info Struktur initialisieren
-		png_set_IHDR(png_ptr, info_ptr,
-		             Width,                          // Breite
-		             Height,                         // Höhe
-		             8,                              // Bittiefe pro Kanal
-		             PNG_COLOR_TYPE_RGB,             // Farbformat
-		             PNG_INTERLACE_NONE,             // Interlacing-Typ
-		             PNG_COMPRESSION_TYPE_DEFAULT,   // Kompressions-Typ
-		             PNG_FILTER_TYPE_DEFAULT);       // Filter-Typ
-
-		// Rowpointer erstellen
-		vector<png_bytep> RowPointers;
-		RowPointers.reserve(Height);
-		for (uint i = 0; i < Height; i++) {
-			RowPointers.push_back((png_bytep)(&PixelBuffer[Width * i]));
-		}
-		png_set_rows(png_ptr, info_ptr, &RowPointers[0]);
 
-		png_init_io(png_ptr, OutFile);
+bool Screenshot::SaveToFile(Graphics::Surface *Data, Common::WriteStream *Stream) {
+	// Reserve buffer space
+	RGB_PIXEL *pixelBuffer = new RGB_PIXEL[Data->w * Data->h];
 
-		// Bild schreiben
-		png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
+	// Convert the RGBA data to RGB
+	const byte *pSrc = (const byte *)Data->getBasePtr(0, 0);
+	RGB_PIXEL *pDest = pixelBuffer;
 
-		png_destroy_write_struct(&png_ptr, &info_ptr);
-		fclose(OutFile);
+	for (uint y = 0; y < Data->h; y++) {
+		for (uint x = 0; x < Data->w; x++) {
+			uint32 srcPixel = READ_LE_UINT32(pSrc);
+			pSrc += sizeof(uint32);
+			pDest->Red = (srcPixel >> 16) & 0xff;
+			pDest->Green = (srcPixel >> 8) & 0xff;
+			pDest->Blue = srcPixel & 0xff;
+			++pDest;
+		}
 	}
 
-	catch (int) {
-		// Wenn die Datei bereits erstellt wurde, Datei schließen und löschen.
-		if (OutFile) {
-			fclose(OutFile);
-			remove(Filename.c_str());
-		}
+	png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+	if (!png_ptr)
+		error("Could not create PNG write-struct.");
+
+	png_infop info_ptr = png_create_info_struct(png_ptr);
+	if (!info_ptr)
+		error("Could not create PNG info-struct.");
+
+	//  The compression buffer must be large enough to the entire image.
+	// This ensures that only an IDAT chunk is created.
+	// When buffer size is used 110% of the raw data size to be sure.
+	png_set_compression_buffer_size(png_ptr, (Data->w * Data->h * 3 * 110) / 100);
+
+	// Initialise PNG-Info structure
+	png_set_IHDR(png_ptr, info_ptr,
+	             Data->w,                        // Width
+	             Data->h,                        // Height
+	             8,                             // Bits depth
+	             PNG_COLOR_TYPE_RGB,             // Colour type
+	             PNG_INTERLACE_NONE,             // No interlacing
+	             PNG_COMPRESSION_TYPE_DEFAULT,   // Compression type
+	             PNG_FILTER_TYPE_DEFAULT);       // Filter Type
+
+	// Rowpointer erstellen
+	png_bytep *rowPointers = new png_bytep[Data->h];
+	for (uint i = 0; i < Data->h; i++) {
+		rowPointers[i] = (png_bytep)&pixelBuffer[Data->w * i];
+	}
+	png_set_rows(png_ptr, info_ptr, &rowPointers[0]);
 
-		if (info_ptr) png_destroy_write_struct(0, &info_ptr);
-		if (png_ptr) png_destroy_write_struct(&png_ptr, (png_infopp) 0);
+	// Write out the png data to the file
+	png_set_write_fn(png_ptr, (void *)Stream, userWriteFn, userFlushFn);
+	png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
 
-		BS_LOG_ERRORLN("Could not create screenshot (\"%s\").", Filename.c_str());
-		return false;
-	}
-#else
-	warning("STUB: BS_Screenshot::SaveToFile(%d, %d, .., %s)", Width, Height, Filename.c_str());
-#endif
+	png_destroy_write_struct(&png_ptr, &info_ptr);
+
+	delete[] pixelBuffer;
+	delete[] rowPointers;
 
 	return true;
 }
 
 // -----------------------------------------------------------------------------
 
-bool Screenshot::SaveThumbnailToFile(uint Width, uint Height, const byte *Data, const Common::String &Filename) {
-#if 0
-	//
-	// Diese Methode nimmt ein Screenshot mit den Maßen von 800x600 und erzeugt einen Screenshot mit den Maßen von 200x125.
-	// Dabei werden je 50 Pixel oben und unten abgeschnitten (die Interface-Leisten im Spiel). Das verbleibende Bild von 800x500 wird auf
-	// ein 16tel seiner Größe reduziert, indem es in 4x4 Pixelblöcke ausgeteilt wird und der Durchschnitt jedes Blockes einen Pixel des Zielbildes generiert.
-	// Abschließend wird das Ergebnis als PNG-Datei unter dem übergebenen Dateinamen gespeichert.
-	//
-
-	// Die Ausgangsgröße muss 800x600 sein.
-	if (Width != 800 || Height != 600) {
+Common::MemoryReadStream *Screenshot::createThumbnail(Graphics::Surface *Data) {
+	// This method takes a screen image with a dimension of 800x600, and creates a screenshot with a dimension of 200x125.
+	// First 50 pixels are cut off the top and bottom (the interface boards in the game). The remaining image of 800x500 
+	// will be on a 16th of its size, reduced by being handed out in 4x4 pixel blocks and the average of each block 
+	// generates a pixel of the target image. Finally, the result as a PNG file is stored as a file.
+
+	// The source image must be 800x600.
+	if (Data->w != 800 || Data->h != 600 || Data->bytesPerPixel != 4) {
 		BS_LOG_ERRORLN("The sreenshot dimensions have to be 800x600 in order to be saved as a thumbnail.");
 		return false;
 	}
 
-	// Buffer für die Zieldaten erstellen (RGBA Bild mit den Maßen 200x125).
-	vector<uint> ThumbnailData(200 * 125);
+	// Buffer for the output thumbnail
+	Graphics::Surface thumbnail;
+	thumbnail.create(200, 125, 4);
 
 	// Über das Zielbild iterieren und einen Pixel zur Zeit berechnen.
 	uint x, y;
 	x = y = 0;
-	for (vector<uint>::iterator Iter = ThumbnailData.begin(); Iter != ThumbnailData.end(); ++Iter) {
-		// Durchschnitt über 4x4 Pixelblock im Quellbild bilden.
-		uint Alpha, Red, Green, Blue;
-		Alpha = Red = Green = Blue = 0;
-		for (uint j = 0; j < 4; ++j) {
-			for (uint i = 0; i < 4; ++i) {
-				uint Pixel = Data[((y * 4) + j + 50) * 800 + ((x * 4) + i)];
-				Alpha += (Pixel >> 24);
-				Red += (Pixel >> 16) & 0xff;
-				Green += (Pixel >> 8) & 0xff;
-				Blue += Pixel & 0xff;
+	
+	for (byte *pDest = (byte *)thumbnail.pixels; pDest < ((byte *)thumbnail.pixels + thumbnail.pitch * thumbnail.h); ) {
+		// Get an average over a 4x4 pixel block in the source image
+		int alpha, red, green, blue;
+		alpha = red = green = blue = 0;
+		for (int j = 0; j < 4; ++j) {
+			const uint32 *srcP = (const uint32 *)Data->getBasePtr(x * 4, y * 4 + j + 50);
+			for (int i = 0; i < 4; ++i) {
+				uint32 pixel = READ_LE_UINT32(srcP + i);
+				alpha += (pixel >> 24);
+				red += (pixel >> 16) & 0xff;
+				green += (pixel >> 8) & 0xff;
+				blue += pixel & 0xff;
 			}
 		}
 
-		// Zielpixel schreiben.
-		*Iter = ((Alpha / 16) << 24) | ((Red / 16) << 16) | ((Green / 16) << 8) | (Blue / 16);
+		// Write target pixel
+		*pDest++ = blue / 16;
+		*pDest++ = green / 16;
+		*pDest++ = red / 16;
+		*pDest++ = alpha / 16;
 
-		// Mitzählen an welcher Stelle im Zielbild wir uns befinden.
+		// Move to next block
 		++x;
-		if (x == 200) {
+		if (x == thumbnail.w) {
 			x = 0;
 			++y;
 		}
 	}
 
-	// Bild als PNG Speichern.
-	return SaveToFile(200, 125, ThumbnailData, Filename);
-#else
-	warning("STUB: BS_Screenshot::SaveThumbnailToFile(%d, %d, .., %s)", Width, Height, Filename.c_str());
+	// Create a PNG representation of the thumbnail data
+	Common::MemoryWriteStreamDynamic *stream = new Common::MemoryWriteStreamDynamic();
+	SaveToFile(&thumbnail, stream);
 
-	return true;
-#endif
+	// Output a MemoryReadStream that encompasses the written data
+	Common::MemoryReadStream *result = new Common::MemoryReadStream(stream->getData(), stream->size(),
+		DisposeAfterUse::YES);
+	return result;
 }
 
 } // End of namespace Sword25
diff --git a/engines/sword25/gfx/screenshot.h b/engines/sword25/gfx/screenshot.h
index 73a14c04db..d328130b3f 100644
--- a/engines/sword25/gfx/screenshot.h
+++ b/engines/sword25/gfx/screenshot.h
@@ -39,6 +39,7 @@
 // Includes
 // -----------------------------------------------------------------------------
 
+#include "graphics/surface.h"
 #include "sword25/kernel/common.h"
 
 namespace Sword25 {
@@ -49,8 +50,8 @@ namespace Sword25 {
 
 class Screenshot {
 public:
-	static bool SaveToFile(uint Width, uint Height, const byte *Data, const Common::String &Filename);
-	static bool SaveThumbnailToFile(uint Width, uint Height, const byte *Data, const Common::String &Filename);
+	static bool SaveToFile(Graphics::Surface *Data, Common::WriteStream *Stream);
+	static Common::MemoryReadStream *createThumbnail(Graphics::Surface *Data);
 };
 
 } // End of namespace Sword25