Ticket #7996: screenshot3.diff

scummvm/Makefile

@@ -31 +31 @@
 DEFINES += -DCOMPRESSED_SOUND_FILE
 LIBS    += -lmad
 
+# Uncomment this to activate the PNG lib for screenshots
+# DEFINES += -DHAVE_LIBPNG
+# LIBS    += -lpng
+
 # Uncomment this to activate the ALSA lib for midi
 # DEFINES += -DUSE_ALSA
 # LIBS    += -lasound

scummvm/common/engine.cpp

@@ -18 +18 @@
  * $Header: /cvsroot/scummvm/scummvm/common/engine.cpp,v 1.6 2002/09/26 12:29:10 fingolfin Exp $
  */
 
+#ifdef HAVE_LIBPNG
+#include <png.h>
+#endif
+
 #include "stdafx.h"
 #include "engine.h"
 #include "gameDetector.h"
 #include "config-file.h"
+#include "util.h"
 #include "scumm/scumm.h"
 #include "simon/simon.h"
 #include "sound/mixer.h"
@@ -77 +82 @@
         return dir;
 }
 
+void Engine::saveScreenshot(OSystem *syst)
+{
+#ifdef HAVE_LIBPNG
+        png_structp png_ptr;
+        png_infop info_ptr;
+        char filename[255];
+        const char *savedir;
+        int16 *buf;
+        png_byte *image;
+        int i, j;
+
+        savedir = getSavePath();
+
+        // FIXME: Is there a better way of making a temporary filename? Should
+        // it be made into a separate function?
+
+        for (i = 0; i < 1000; i++) {
+                sprintf(filename, "%sscr%03d.png", savedir, i);
+                _fp = fopen(filename, "rb");
+                if (!_fp)
+                        break;
+        }
+
+        if (_fp) {
+                warning("Could not create temporary filename for screenshot");
+                fclose(_fp);
+                return;
+        }
+
+        _fp = fopen(filename, "wb");
+        if (!_fp) {
+                warning("Could not create temporary file for screenshot");
+                return;
+        }
+
+        // FIXME: We need a way to get the correct screen size. For now, use
+        // the same dirty hack assumptions as newgui.cpp
+
+        int screen_height = 240;
+        int screen_width = 320;
+        int screen_pitch = 320;
+
+        // Apparently it's possible to slim down libpng quite a bit, but I'm
+        // going to assume that all the basic features are still there.
+
+        png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
+                (png_voidp) NULL, (png_error_ptr) NULL, (png_error_ptr) NULL);
+
+        if (!png_ptr) {
+                warning("Could not create PNG write struct");
+                fclose(_fp);
+                return;
+        }
+
+        info_ptr = png_create_info_struct(png_ptr);
+        if (!info_ptr) {
+                warning("Could not create PNG info struct");
+                fclose(_fp);
+                png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
+                return;
+        }
+
+#ifndef PNG_SETJMP_NOT_SUPPORTED
+#       ifndef png_jmpbuf
+#               define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
+#       endif
+
+        if (setjmp(png_jmpbuf(png_ptr))) {
+                warning("Internal libpng error");
+                fclose(_fp);
+                png_destroy_write_struct(&png_ptr, &info_ptr);
+                return;
+        }
+#endif
+
+        png_init_io(png_ptr, _fp);
+
+        buf = (int16 *) malloc(screen_width * screen_height * sizeof(int16));
+        if (!buf) {
+                warning("Could not allocate memory for screen buffer");
+                fclose(_fp);
+                png_destroy_write_struct(&png_ptr, &info_ptr);
+                return;
+        }
+
+        image = (png_byte *) calloc(screen_width, 3 * sizeof(png_byte));
+        if (!image) {
+                warning("Could not allocate memory for PNG image");
+                free(buf);
+                fclose(_fp);
+                png_destroy_write_struct(&png_ptr, &info_ptr);
+                return;
+        }
+
+        // Grab a screenshot
+
+        // FIXME: I'd really like some way of getting the image that is
+        // actually being displayed.
+
+        syst->show_overlay();
+        syst->grab_overlay(buf, screen_pitch);
+        syst->hide_overlay();
+
+        png_set_IHDR(png_ptr, info_ptr, screen_width, screen_height, 8,
+                PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
+                PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+        png_write_info(png_ptr, info_ptr);
+
+        for (i = 0; i < screen_height; i++) {
+                for (j = 0; j < screen_width; j++) {
+                        image[j * 3 + 0] = RED_FROM_16(buf[i * screen_width + j]);
+                        image[j * 3 + 1] = GREEN_FROM_16(buf[i * screen_width + j]);
+                        image[j * 3 + 2] = BLUE_FROM_16(buf[i * screen_width + j]);
+                }
+
+                png_write_rows(png_ptr, &image, 1);
+        }
+
+        png_write_end(png_ptr, info_ptr);
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+
+        free(buf);
+        free(image);
+        fclose(_fp);
+
+        debug(1, "Saved snapshot in %s", filename);
+#else
+        // FIXME: As a fallback, we should have an image-writing function that
+        // doesn't require any external libraries.
+        warning("No PNG support! Screenshot feature disabled");
+#endif
+}
+
 Engine *Engine::createFromDetector(GameDetector *detector, OSystem *syst)
 {
         Engine *engine;

scummvm/common/engine.h

@@ -55 +55 @@
 
         const char *getGameDataPath() const { return _gameDataPath; }
 
+        void saveScreenshot(OSystem *syst);
+        
         // Create a new engine object based on the detector - either 
         // a Scumm or a SimonState object currently.
         static Engine *createFromDetector(GameDetector *detector, OSystem *syst);
+        
+        // Hack to avoid scary GCC warning in saveScreenshot()
+        FILE *_fp;
 };
 
 #if defined(__GNUC__)

scummvm/scumm/scummvm.cpp

@@ -1347 +1347 @@
                                                 g_debugger.attach(this);
                                         else if (event.kbd.keycode=='s')
                                                 resourceStats();
+                                } else if (event.kbd.flags==OSystem::KBD_ALT) {
+                                        if (event.kbd.keycode=='s')
+                                                saveScreenshot(_system);
                                 } else
                                         _keyPressed = event.kbd.ascii;  // Normal key press, pass on to the game.
                                 break;

scummvm/simon/simon.cpp

@@ -4407 +4407 @@
                                         if (event.kbd.keycode == 'f') {
                                                 _fast_mode ^= 1;
                                         }
+                                } else if (event.kbd.flags == OSystem::KBD_ALT) {
+                                        if (event.kbd.keycode == 's') {
+                                                saveScreenshot(_system);
+                                        }
                                 }
                                 _key_pressed = (byte)event.kbd.ascii;
                                 break;