Ticket #9152: cleanup.4.diff

configure

@@ -1647 +1647 @@
 # Enable 16bit support only for backends which support it
 #
 case $_backend in
-        dreamcast | samsungtv | sdl | wii)
+        dreamcast | samsungtv | sdl | wii | psp)
                 if test "$_16bit" = auto ; then
                         _16bit=yes
                 else

backends/platform/psp/psploader.h

@@ -135 +135 @@
 }
 
 #endif /* PSPLOADER_H */
-

backends/platform/psp/input.cpp

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $
+ * $Id: osys_psp.cpp 43618 2009-08-21 22:44:49Z joostp $
+ *
+ */ 
+
+// Todo: handle events that should fire because of shift going off 
+// Solution: handle shift on a button-by-button basis, only allowing it when the button is up. Also a inputmap-wide button. At buttonup, shiftstate is inspected per button.
+ 
+//#define __PSP_DEBUG_FUNCS__   /* Uncomment for debugging the stack */
+//#define __PSP_DEBUG_PRINT__ /* Uncomment for debug prints */
+ 
+#include "backends/platform/psp/trace.h"
+
+#include "backends/platform/psp/input.h"
+
+// Defines for working with PSP buttons
+#define CHANGED(x)       (_buttonsChanged & (x))
+#define PRESSED(x)   ((_buttonsChanged & (x)) && (pad.Buttons & (x)))
+#define UNPRESSED(x) ((_buttonsChanged & (x)) && !(pad.Buttons & (x)))
+#define DOWN(x)          (pad.Buttons & (x))
+#define UP(x)            (!(pad.Buttons & (x)))
+#define PSP_DPAD         (PSP_CTRL_DOWN|PSP_CTRL_UP|PSP_CTRL_LEFT|PSP_CTRL_RIGHT)
+#define PSP_4BUTTONS (PSP_CTRL_CROSS | PSP_CTRL_CIRCLE | PSP_CTRL_TRIANGLE | PSP_CTRL_SQUARE)
+#define PSP_TRIGGERS (PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER)
+
+#define PAD_CHECK_TIME  53
+
+void InputHandler::init() {
+        sceCtrlSetSamplingCycle(0);     // set sampling to vsync. n = n usecs
+        sceCtrlSetSamplingMode(1);  // analog
+}
+
+bool InputHandler::getAllInputs(Common::Event &event) {
+        DEBUG_ENTER_FUNC();
+        
+        uint32 time = g_system->getMillis();    // may not be necessary with read
+        if (time - _lastPadCheckTime < PAD_CHECK_TIME) {
+                DEBUG_EXIT_FUNC();
+                return false;
+        }
+
+        _lastPadCheckTime = time;
+        SceCtrlData pad;
+
+        sceCtrlPeekBufferPositive(&pad, 1);     // Peek ignores sleep. Read sleeps thread
+
+        bool haveEvent;
+
+        memset(&event, 0, sizeof(event));
+
+        if (_keyboard->isVisible())
+                haveEvent = _keyboard->processInput(event, pad);
+        else 
+                haveEvent = getEvent(event, pad);
+
+        if (haveEvent)
+        {       
+                PSP_DEBUG_PRINT("Have event[%s]\n", haveEvent ? "true" : "false");
+                PSP_DEBUG_PRINT("event.type[%d]\n", event.type);
+        }       
+
+        DEBUG_EXIT_FUNC();
+        
+        return haveEvent;
+}
+
+bool InputHandler::getEvent(Common::Event &event, SceCtrlData &pad) {
+        DEBUG_ENTER_FUNC();
+
+        _buttonsChanged = pad.Buttons ^ _prevButtons;
+        bool haveEvent = false;
+
+        // Collect events from different sources
+        haveEvent = getDpadEvent(event, pad);
+                
+        if (!haveEvent)
+                haveEvent = getButtonEvent(event, pad);
+                
+        if (!haveEvent)
+                haveEvent = getNubEvent(event, pad);            
+
+        _prevButtons = pad.Buttons;
+        
+        DEBUG_EXIT_FUNC();
+        return haveEvent;
+}
+
+bool InputHandler::getDpadEvent(Common::Event &event, SceCtrlData &pad) {
+        DEBUG_ENTER_FUNC();
+        
+        int newDpadX = 0, newDpadY = 0;
+        bool haveEvent = false;
+
+        if (DOWN(PSP_CTRL_UP)) {
+                newDpadY++;
+                if (DOWN(PSP_CTRL_RTRIGGER))    // Shifting causes diagonals
+                        newDpadX++;
+        }
+        if (DOWN(PSP_CTRL_RIGHT)) {
+                newDpadX++;
+                if (DOWN(PSP_CTRL_RTRIGGER))
+                        newDpadY--;
+        }
+        if (DOWN(PSP_CTRL_DOWN)) {
+                newDpadY--;
+                if (DOWN(PSP_CTRL_RTRIGGER))
+                        newDpadX--;
+        }
+        if (DOWN(PSP_CTRL_LEFT)) {
+                newDpadX--;
+                if (DOWN(PSP_CTRL_RTRIGGER))
+                        newDpadY++;
+        }
+        
+        if (newDpadX != _dpadX || newDpadY != _dpadY) {
+                if (_dpadX == 0 && _dpadY == 0) {               // We were in the middle so we pressed dpad
+                        event.type = Common::EVENT_KEYDOWN;
+                        event.kbd.keycode = translateDpad(newDpadX, newDpadY);
+                        event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';        // Get ascii
+                        _dpadX = newDpadX;
+                        _dpadY = newDpadY;
+                }
+                else if (newDpadX == 0 && newDpadY == 0) {// We're now centered so we unpressed dpad
+                        event.type = Common::EVENT_KEYUP;
+                        event.kbd.keycode = translateDpad(_dpadX, _dpadY);
+                        event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';
+                        _dpadX = newDpadX;
+                        _dpadY = newDpadY;
+                } else {        // we moved from one pressed dpad direction to another one
+                        event.type = Common::EVENT_KEYUP;       // first release the last dpad direction
+                        event.kbd.keycode = translateDpad(_dpadX, _dpadY);
+                        event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';
+                        _dpadX = 0; // so that we'll pick up a new dpad movement the next round
+                        _dpadY = 0;
+                }
+                
+                PSP_DEBUG_PRINT("Keypad event. DpadX[%d], DpadY[%d]\n", _dpadX, _dpadY);
+                haveEvent = true;
+        }
+
+        DEBUG_EXIT_FUNC();
+        return haveEvent;
+}
+
+inline Common::KeyCode InputHandler::translateDpad(int x, int y) {
+        DEBUG_ENTER_FUNC();
+        Common::KeyCode key;
+
+        if (x == -1) {
+                if (y == -1)
+                        key = Common::KEYCODE_KP1;
+                else if (y == 0)
+                        key = Common::KEYCODE_KP4;
+                else /* y == 1 */
+                        key = Common::KEYCODE_KP7;
+        } else if (x == 0) {
+                if (y == -1)
+                        key = Common::KEYCODE_KP2;
+                else /* y == 1 */
+                        key = Common::KEYCODE_KP8;
+        } else {/* x == 1 */
+                if (y == -1)
+                        key = Common::KEYCODE_KP3;
+                else if (y == 0)
+                        key = Common::KEYCODE_KP6;
+                else /* y == 1 */
+                        key = Common::KEYCODE_KP9;
+        }
+
+        DEBUG_EXIT_FUNC();
+        return key;
+}
+
+
+bool InputHandler::getButtonEvent(Common::Event &event, SceCtrlData &pad) {
+        DEBUG_ENTER_FUNC();
+        bool haveEvent = false;
+
+        if (PRESSED(PSP_CTRL_SELECT))
+                _keyboard->setVisible(true);
+
+        else if (CHANGED(PSP_4BUTTONS | PSP_TRIGGERS | PSP_CTRL_START)) {
+                if (CHANGED(PSP_CTRL_CROSS)) {
+                        event.type = DOWN(PSP_CTRL_CROSS) ? Common::EVENT_LBUTTONDOWN : Common::EVENT_LBUTTONUP;
+                        event.mouse.x = _cursor->getX();        // Could this have to do with SCI enter problem?
+                        event.mouse.y = _cursor->getY();
+                        PSP_DEBUG_PRINT("%s\n", event.type == Common::EVENT_LBUTTONDOWN ? "LButtonDown" : "LButtonUp"); 
+                } else if (CHANGED(PSP_CTRL_CIRCLE)) {
+                        event.type = DOWN(PSP_CTRL_CIRCLE) ? Common::EVENT_RBUTTONDOWN : Common::EVENT_RBUTTONUP;
+                        event.mouse.x = _cursor->getX();
+                        event.mouse.y = _cursor->getY();
+                        PSP_DEBUG_PRINT("%s\n", event.type == Common::EVENT_LBUTTONDOWN ? "RButtonDown" : "RButtonUp");
+                } else {
+                        //any of the other buttons.
+                        event.type = _buttonsChanged & pad.Buttons ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP;
+                        event.kbd.ascii = 0;
+                        event.kbd.flags = 0;
+
+                        if (CHANGED(PSP_CTRL_LTRIGGER)) {
+                                event.kbd.keycode = Common::KEYCODE_ESCAPE;
+                                event.kbd.ascii = 27;
+                        } else if (CHANGED(PSP_CTRL_START)) {
+                                event.kbd.keycode = Common::KEYCODE_F5;
+                                event.kbd.ascii = Common::ASCII_F5;
+                                if (DOWN(PSP_CTRL_RTRIGGER)) {
+                                        event.kbd.flags |= Common::KBD_CTRL;    // Main menu to allow RTL
+                                }
+                        } else if (CHANGED(PSP_CTRL_SQUARE)) {
+                                event.kbd.keycode = Common::KEYCODE_PERIOD;
+                                event.kbd.ascii = '.';
+                        } else if (CHANGED(PSP_CTRL_TRIANGLE)) {
+                                event.kbd.keycode = Common::KEYCODE_RETURN;
+                                event.kbd.ascii = '\r';
+                        } else if (DOWN(PSP_CTRL_RTRIGGER)) {                   // An event
+                                event.kbd.flags |= Common::KBD_SHIFT;
+                        }
+                        PSP_DEBUG_PRINT("Ascii[%d]. Key %s.\n", event.kbd.ascii, event.type == Common::EVENT_KEYDOWN ? "down" : "up" );
+                }
+                
+                haveEvent = true;
+        }
+        
+        DEBUG_EXIT_FUNC();
+        return haveEvent;
+}
+
+bool InputHandler::getNubEvent(Common::Event &event, SceCtrlData &pad) {
+        DEBUG_ENTER_FUNC();
+
+        bool haveEvent = false;
+        int32 analogStepX = pad.Lx;             // Goes up to 255. 
+        int32 analogStepY = pad.Ly;
+
+        int32 oldX = _cursor->getX();
+        int32 oldY = _cursor->getY();
+
+        analogStepX = modifyNubAxisMotion(analogStepX);
+        analogStepY = modifyNubAxisMotion(analogStepY);
+        
+        if (analogStepX != 0 || analogStepY != 0) {
+        
+                PSP_DEBUG_PRINT("raw x[%d], y[%d]\n", analogStepX, analogStepY);
+                
+                // If no movement then this has no effect
+                if (DOWN(PSP_CTRL_RTRIGGER)) {
+                        // Fine control mode for analog
+                                if (analogStepX != 0) {
+                                        if (analogStepX > 0)
+                                                _cursor->increaseXY(2, 0);
+                                        else
+                                                _cursor->increaseXY(-2, 0);
+                                }
+
+                                if (analogStepY != 0) {
+                                        if (analogStepY > 0)
+                                                _cursor->increaseXY(0, 2);
+                                        else
+                                                _cursor->increaseXY(0, -2);
+                                }
+                } else {        // Regular speed movement
+                        _cursor->increaseXY(analogStepX, 0);
+                        _cursor->increaseXY(0, analogStepY);
+                }
+
+                int32 newX = _cursor->getX();
+                int32 newY = _cursor->getY();
+
+                if ((oldX != newX) || (oldY != newY)) {
+                        event.type = Common::EVENT_MOUSEMOVE;
+                        event.mouse.x = newX;
+                        event.mouse.y = newY;
+                        haveEvent = true;
+                        
+                        PSP_DEBUG_PRINT("Nub event. X[%d], Y[%d]\n", newX, newY);
+                }
+        }
+        DEBUG_EXIT_FUNC();
+        return haveEvent;
+}
+
+inline int32 InputHandler::modifyNubAxisMotion(int32 input) {
+        DEBUG_ENTER_FUNC();
+        const int MIN_NUB_MOTION = 30;
+        
+        input -= 128;   // Center on 0.
+        
+        if (input < -MIN_NUB_MOTION - 1)
+                input += MIN_NUB_MOTION + 1;    // reduce the velocity
+        else if (input > MIN_NUB_MOTION)
+                input -= MIN_NUB_MOTION;        // same
+        else                            // between these points, dampen the response to 0       
+                input = 0;
+        
+        
+        DEBUG_EXIT_FUNC();
+        return input;   
+}

backends/platform/psp/display_client.cpp

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $
+ * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $
+ *
+ */
+
+#include <pspgu.h>
+#include <pspdisplay.h>
+#include <psputils.h>
+
+#include "common/scummsys.h" 
+#include "backends/platform/psp/display_client.h"
+#include "backends/platform/psp/display_manager.h"
+#include "backends/platform/psp/memory.h"
+
+//#define __PSP_DEBUG_FUNCS__   /* For debugging the stack */
+//#define __PSP_DEBUG_PRINT__
+#include "backends/platform/psp/trace.h"
+
+#define PSP_BUFFER_WIDTH (512)
+#define PSP_SCREEN_WIDTH        480
+#define PSP_SCREEN_HEIGHT       272
+#define PSP_FRAME_SIZE (PSP_BUFFER_WIDTH * PSP_SCREEN_HEIGHT)
+
+DisplayManager *GuRenderer::_displayManager = 0;
+
+
+// class Palette ------------------------------------------------------------
+//
+void Palette::clear() {
+        DEBUG_ENTER_FUNC();
+
+        if (_values && _numOfEntries)
+                memset(_values, 0, getSizeInBytes());
+                
+        PSP_DEBUG_PRINT("_values[%p]\n", _values);
+                
+        DEBUG_EXIT_FUNC();
+}
+
+// Used to clear the specific keycolor
+//
+void Palette::setColorPositionAlpha(uint32 position, bool alpha) {
+        DEBUG_ENTER_FUNC();
+        
+        assert(_values);
+        assert(position < _numOfEntries);
+        
+        PSP_DEBUG_PRINT("position[%d], numofEntries[%u], bpp[%u], values[%p]\n", position, _numOfEntries,
+                        _pixelFormat.bitsPerPixel, _values);
+
+        if (_numOfEntries <= 16)
+                position &= 0xF;
+        else if (_numOfEntries <= 256)
+                position &= 0xFF;
+        
+        switch (_pixelFormat.bitsPerPixel) {
+        case 16: {              
+                uint16 *shortVal = (uint16 *)&_values[_pixelFormat.pixelsToBytes(position)];
+                *shortVal = _pixelFormat.setColorAlpha((uint32)*shortVal, alpha ? 255 : 0);
+                }
+                break;
+        case 32: {
+                uint32 *wordVal = (uint32 *)&_values[_pixelFormat.pixelsToBytes(position)];
+                *wordVal = _pixelFormat.setColorAlpha((uint32)*wordVal, alpha ? 255 : 0);
+                }
+                break;
+        default:
+                PSP_ERROR("Incorrect bits per pixel value[%u]\n", _pixelFormat.bitsPerPixel);
+        }
+                
+        DEBUG_EXIT_FUNC();
+}
+
+//      Set some of the palette to color values in array
+//      By default, ScummVm doesn't support alpha values in palettes
+void Palette::setPartial(const byte *colors, uint32 start, uint32 num, bool supportsAlpha /* = false */) {
+        DEBUG_ENTER_FUNC();
+
+        assert(_values);
+        assert(_numOfEntries);
+        
+        const byte *src = colors;
+        
+        if (start + num > _numOfEntries)        // Check boundary
+                num = _numOfEntries - start;
+
+        if (_pixelFormat.bitsPerPixel == 16) {
+                uint16 *palette = (uint16 *)_values;
+                palette += start;
+                
+                for (uint32 i = 0; i < num; ++i) {
+                        byte alphaVal = supportsAlpha ? src[3] : 0xFF;
+                        *palette = (uint16)_pixelFormat.rgbaToColor(src[0], src[1], src[2], alphaVal);
+                        src += 4;       
+                        palette++;
+                }
+        }
+        else if (_pixelFormat.bitsPerPixel == 32) {
+                uint32 *palette = (uint32 *)_values;
+                palette += start;
+                
+                for (uint32 i = 0; i < num; ++i) {
+                        byte alphaVal = supportsAlpha ? src[3] : 0xFF;
+                        *palette = _pixelFormat.rgbaToColor(src[0], src[1], src[2], alphaVal);
+                        src += 4;       
+                        palette++;
+                }
+        }
+        
+        DEBUG_EXIT_FUNC();
+}
+
+// Sets pixel format and number of entries by the buffer's pixel format */
+void Palette::setPixelFormats(PSPPixelFormat::Type paletteType, PSPPixelFormat::Type bufferType, bool swapRedBlue /* = false */) {
+        DEBUG_ENTER_FUNC();
+        
+        if (paletteType == PSPPixelFormat::Type_Unknown) 
+                PSP_ERROR("Unknown paletteType[%u]\n", paletteType);
+
+        switch (bufferType) {
+        case PSPPixelFormat::Type_Palette_8bit:
+                _numOfEntries = 256;
+                break;
+        case PSPPixelFormat::Type_Palette_4bit:
+                _numOfEntries = 16;
+                break;
+        case PSPPixelFormat::Type_Unknown:
+        case PSPPixelFormat::Type_None:
+                PSP_ERROR("Unhandled bufferType[%u]\n", bufferType);
+                break;
+        default:                // No palette
+                _numOfEntries = 0;
+                break;
+        }
+        
+        _pixelFormat.set(paletteType, swapRedBlue);
+        
+        DEBUG_EXIT_FUNC();
+}
+
+bool Palette::allocate() {
+        DEBUG_ENTER_FUNC();
+        PSP_DEBUG_PRINT("_numOfEntries[%u]\n", _numOfEntries);
+        PSP_DEBUG_PRINT("_pixelFormat: format[%u], bpp[%u]\n", _pixelFormat.format, _pixelFormat.bitsPerPixel);
+
+        if (_values) {
+                free (CACHED(_values));
+                _values = 0;
+        }
+
+        // We allocate on 64bytes to get a cache line, and round up to 64bytes to get the full line
+        uint32 amountInBytes = getSizeInBytes();
+        if (amountInBytes < 64) 
+                amountInBytes = 64;
+        _values = (byte *)memalign(64, amountInBytes);
+
+        // Use uncached memory
+        GuRenderer::cacheInvalidate(_values, amountInBytes);
+        _values = UNCACHED(_values);
+        
+        if (!_values) {
+                PSP_ERROR("Couldn't allocate palette.\n");
+                DEBUG_EXIT_FUNC();
+                return false;
+        }
+        
+        PSP_DEBUG_PRINT("_values[%p]\n", _values);
+        clear();
+        
+        DEBUG_EXIT_FUNC();
+        return true;
+}
+
+void Palette::deallocate() {
+        DEBUG_ENTER_FUNC();
+        
+        free (CACHED(_values));
+        _values = 0;
+        _numOfEntries = 0;
+        
+        DEBUG_EXIT_FUNC();
+}
+
+// Copy some of the palette to an array of colors
+//
+void Palette::getPartial(byte *colors, uint start, uint num) {
+        DEBUG_ENTER_FUNC();
+
+        assert(_values);
+        assert(_numOfEntries);
+        
+        uint32 r, g, b, a;
+
+        if (start + num > _numOfEntries)        // Check boundary
+                num = _numOfEntries - start;
+        
+        if (_pixelFormat.bitsPerPixel == 16) {  
+                uint16 *palette = (uint16 *)_values;
+                palette += start;
+                
+                for (uint32 i = start; i < start + num; i++) {
+                        _pixelFormat.colorToRgba(*palette, r, g, b, a);
+                        
+                        *colors++ = (byte)r;
+                        *colors++ = (byte)g;
+                        *colors++ = (byte)b;
+                        *colors++ = (byte)a;
+                        palette++;
+                }
+        } else if (_pixelFormat.bitsPerPixel == 32) {   
+                uint32 *palette = (uint32 *)_values;
+                palette += start;
+                
+                for (uint32 i = start; i < start + num; i++) {
+                        _pixelFormat.colorToRgba(*palette, r, g, b, a);
+                        
+                        *colors++ = (byte)r;
+                        *colors++ = (byte)g;
+                        *colors++ = (byte)b;
+                        *colors++ = (byte)a;
+                        palette++;
+                }
+        }
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void Palette::setSingleColorRGBA(uint32 num, byte r, byte g, byte b, byte a) {  
+        // DEBUG_ENTER_FUNC();
+        uint16 *shortValues;
+        uint32 *wordValues;
+        
+        assert (_values);
+        assert (num < _numOfEntries);
+        
+        switch (_pixelFormat.bitsPerPixel) {
+        case 16: 
+                shortValues = (uint16 *)_values;
+                shortValues[num] = _pixelFormat.rgbaToColor(r, g, b, a);
+                break;
+        case 32: 
+                wordValues = (uint32 *)_values;
+                wordValues[num] = _pixelFormat.rgbaToColor(r, g, b, a);         
+                break;
+        default:
+                PSP_ERROR("Incorrect bitsPerPixel[%d]\n", _pixelFormat.bitsPerPixel);
+                break;
+        }
+        // DEBUG_EXIT_FUNC();
+}
+
+// Print to screen
+void Palette::print(uint32 numToPrint /* = 0 */) {
+        if (_numOfEntries > 0) {
+                assert (_values);
+                
+                if (numToPrint > _numOfEntries || numToPrint == 0) 
+                        numToPrint = _numOfEntries;
+                
+                PSP_INFO_PRINT("cursor palette:\n");
+                
+                for (unsigned int i=0; i<numToPrint; i++) {
+                        byte *pcolor = &_values[_pixelFormat.pixelsToBytes(i)];
+                        uint32 color = _pixelFormat.getColorValueAt(pcolor);
+                        
+                        PSP_INFO_PRINT("[%u=%x] ", i, color);
+                }
+        
+                PSP_INFO_PRINT("\n");
+        }
+}
+
+uint32 Palette::getRawColorAt(uint32 position) {
+        byte *pcolor = &_values[_pixelFormat.pixelsToBytes(position)];
+        uint32 color = _pixelFormat.getColorValueAt(pcolor);
+        return color;
+}
+
+uint32 Palette::getRGBAColorAt(uint32 position) {
+        uint32 color = getRawColorAt(position);
+        uint32 r, g, b, a;
+        _pixelFormat.colorToRgba(color, r, g, b, a);
+        return (a << 24 | b << 16 | g << 8 |  r);
+}
+
+// class Buffer ---------------------------------------------------
+
+void Buffer::setPixelFormat(PSPPixelFormat::Type type, bool swapRedBlue) { 
+        if (type == PSPPixelFormat::Type_None ||
+                type == PSPPixelFormat::Type_Unknown)
+                PSP_ERROR("Unhandled buffer format[%u]\n", type);
+                
+        _pixelFormat.set(type, swapRedBlue); 
+}
+
+bool Buffer::hasPalette() {
+        if (_pixelFormat.format == PSPPixelFormat::Type_Palette_8bit ||
+                _pixelFormat.format == PSPPixelFormat::Type_Palette_4bit)
+                return true;
+
+        return false;
+}
+
+/* pitch is in bytes */
+void Buffer::copyFromArray(const byte *buffer, int pitch) {
+        DEBUG_ENTER_FUNC();
+        
+        // We use sourceSize because outside, they won't know what the true size is
+        copyFromRect(buffer, pitch, 0, 0, _sourceSize.width, _sourceSize.height);
+        
+        DEBUG_EXIT_FUNC();
+}
+
+/* pitch is in bytes */
+void Buffer::copyFromRect(const byte *buf, uint32 pitch, int destX, int destY, uint32 recWidth, uint32 recHeight) {
+        // Removed silly clipping code
+        DEBUG_ENTER_FUNC();
+        assert (_pixels);
+        
+        if (recWidth > _sourceSize.width - destX) {
+                recWidth = _sourceSize.width - destX;
+        }
+
+        if (recHeight > _sourceSize.height - destY) {
+                recHeight = _sourceSize.height - destY;
+        }
+
+        if (recWidth <= 0 || recHeight <= 0) {
+                DEBUG_EXIT_FUNC();
+                return;
+        }
+
+        byte *dst = _pixels + _pixelFormat.pixelsToBytes((destY * _width) + destX);
+        
+        uint32 recWidthInBytes = _pixelFormat.pixelsToBytes(recWidth);
+        uint32 realWidthInBytes = _pixelFormat.pixelsToBytes(_width);
+
+        if (pitch == realWidthInBytes && pitch == recWidthInBytes) {
+                //memcpy(dst, buf, _pixelFormat.pixelsToBytes(recHeight * recWidth));
+                Copier::copy(dst, buf, _pixelFormat.pixelsToBytes(recHeight * recWidth), &_pixelFormat);
+        } else {
+                do {
+                        //memcpy(dst, buf, recWidthInBytes);
+                        Copier::copy(dst, buf, recWidthInBytes, &_pixelFormat);
+                        buf += pitch;
+                        dst += realWidthInBytes;
+                } while (--recHeight);
+        }
+        
+        DEBUG_EXIT_FUNC();
+}
+
+/* pitch is in bytes */
+void Buffer::copyToArray(byte *dst, int pitch) {
+        DEBUG_ENTER_FUNC();
+        assert (_pixels);
+        
+        uint32 h = _height;
+        byte *src = _pixels;
+        uint32 sourceWidthInBytes = _pixelFormat.pixelsToBytes(_sourceSize.width);
+        uint32 realWidthInBytes = _pixelFormat.pixelsToBytes(_width);
+
+        do {
+                //memcpy(dst, src, sourceWidthInBytes);
+                Copier::copy(dst, src, sourceWidthInBytes, &_pixelFormat);
+                src += realWidthInBytes;
+                dst += pitch;
+        } while (--h);
+        
+        DEBUG_EXIT_FUNC();
+}
+
+/* We can size the buffer either by texture size (multiple of 2^n) or source size. The GU can
+        really handle both, but is supposed to get only 2^n size buffers */
+void Buffer::setSize(uint32 width, uint32 height, HowToSize textureOrSource/*=kSizeByTextureSize*/) {
+        DEBUG_ENTER_FUNC();
+        PSP_DEBUG_PRINT("w[%u], h[%u], %s\n", width, height, textureOrSource ? "size by source" : "size by texture");
+        
+        _sourceSize.width = width;
+        _sourceSize.height = height;
+
+        _textureSize.width = scaleUpToPowerOfTwo(width);
+        _textureSize.height = scaleUpToPowerOfTwo(height);
+
+        if (textureOrSource == kSizeByTextureSize) {
+                _width = _textureSize.width;
+                _height = _textureSize.height;
+        }
+        else { /* kSizeBySourceSize */
+                _width = _sourceSize.width;
+                _height = _sourceSize.height;
+        }
+        
+        DEBUG_EXIT_FUNC();
+}
+
+/* Scale a dimension (width/height) up to power of 2 for the texture */
+uint32 Buffer::scaleUpToPowerOfTwo(uint32 size) {
+        
+        uint32 textureDimension = 0;
+        if (size <= 16)
+                textureDimension = 16;
+        else if (size <= 32)
+                textureDimension = 32;
+        else if (size <= 64)
+                textureDimension = 64;
+        else if (size <= 128)
+                textureDimension = 128;
+        else if (size <= 256)
+                textureDimension = 256;
+        else
+                textureDimension = 512;
+        
+        PSP_DEBUG_PRINT("power of 2 = %u\n", textureDimension);
+
+        return textureDimension;
+}
+
+bool Buffer::allocate(bool inVram/*=false*/) {
+        DEBUG_ENTER_FUNC();
+        
+        PSP_DEBUG_PRINT("_width[%u], _height[%u]\n", _width, _height);
+        PSP_DEBUG_PRINT("_pixelFormat: format[%u], bpp[%u]\n", _pixelFormat.format, _pixelFormat.bitsPerPixel);
+
+        if (_pixels) {
+                if (VramAllocator::isAddressInVram(_pixels))    // Check if in VRAM
+                        VramAllocator::instance().deallocate(_pixels);
+                else    // not in VRAM
+                        free (CACHED(_pixels));
+                        
+                _pixels = 0;    
+        }
+
+        uint32 size = getSizeInBytes();
+        
+        if (inVram) {
+                _pixels = (byte *)VramAllocator::instance().allocate(size);
+        } 
+        
+        if (!_pixels) { // Either we are not in vram or we didn't manage to allocate in vram
+                // Align to 64 bytes. All normal buffer sizes are multiples of 64 anyway
+                _pixels = (byte *)memalign(64, size);
+        }
+
+        if (!_pixels) {
+                PSP_ERROR("couldn't allocate buffer.\n");
+                DEBUG_EXIT_FUNC();
+                return false;
+        }
+        
+        // Use uncached memory
+        GuRenderer::cacheInvalidate(_pixels, size);
+        _pixels = UNCACHED(_pixels);
+
+        clear();
+        DEBUG_EXIT_FUNC();
+        return true;
+}
+
+void Buffer::deallocate() {
+        DEBUG_ENTER_FUNC();
+
+        if (!_pixels)
+                return;
+                
+        if (VramAllocator::isAddressInVram(_pixels))    // Check if in VRAM
+                VramAllocator::instance().deallocate(_pixels);
+        else
+                free(CACHED(_pixels));
+                
+        _pixels = 0;
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void Buffer::clear() {
+        DEBUG_ENTER_FUNC();
+        
+        if (_pixels)
+                memset(_pixels, 0, getSizeInBytes());
+                
+        DEBUG_EXIT_FUNC();
+}
+
+/* Convert 4 bit images to match weird PSP format */
+void Buffer::flipNibbles() {
+        DEBUG_ENTER_FUNC();
+        
+        if (_pixelFormat.bitsPerPixel != 4) 
+                return;
+                
+        assert(_pixels);        
+        
+        uint32 *dest = (uint32 *)_pixels;
+
+        for (uint32 i = 0; i < getSourceHeight(); i++) {
+                for (uint32 j = 0; j < (getWidth() >> 3); j++) {        // /8 because we do it in 32bit chunks
+                        uint32 val = *dest;
+                        *dest++ = ((val >> 4) & 0x0F0F0F0F) | ((val << 4) & 0xF0F0F0F0);
+                }
+        }
+
+        DEBUG_EXIT_FUNC();
+}
+
+// Print buffer contents to screen (only source size is printed out)
+void Buffer::print(uint32 mask, uint32 numToPrint /*=0*/) {
+        assert(_pixels);
+        
+        if (numToPrint > _sourceSize.width * _sourceSize.height || numToPrint == 0)
+                numToPrint = _sourceSize.width * _sourceSize.height;
+        
+        PSP_INFO_PRINT("buffer: \n");
+        PSP_INFO_PRINT("width[%u], height[%u]\n\n", _sourceSize.width, _sourceSize.height);
+        
+        for (unsigned int i=0; i < _sourceSize.height; i++) {
+                for (unsigned int j=0; j < _sourceSize.width; j++) {
+                        if (numToPrint <= 0)    // check if done
+                                break;
+                                
+                        byte *pcolor = &_pixels[_pixelFormat.pixelsToBytes((i * _width) + j)];
+                        uint32 color = _pixelFormat.getColorValueAt(pcolor);
+ 
+                        //if (color != 0) PSP_INFO_PRINT("[%x] ", color);
+                        PSP_INFO_PRINT("[%x] ", mask & color);
+                                
+                        numToPrint--;
+                }
+                PSP_INFO_PRINT("\n");
+        }
+        PSP_INFO_PRINT("\n");
+}
+
+// class GuRenderer -------------------------------------------------
+//#define __PSP_DEBUG_FUNCS__   /* For debugging the stack */
+//#define __PSP_DEBUG_PRINT__
+
+#include "backends/platform/psp/trace.h"
+
+
+void GuRenderer::render() {
+        DEBUG_ENTER_FUNC();
+        PSP_DEBUG_PRINT("Buffer[%p] Palette[%p]\n", _buffer->getPixels(), _palette->getRawValues());
+
+        setMaxTextureOffsetByIndex(0, 0);
+        
+        guProgramDrawBehavior();
+        
+        if (_buffer->hasPalette())
+                guLoadPalette();
+        
+        guProgramTextureFormat();
+        guLoadTexture();
+        
+        Vertex *vertices = guGetVertices();     
+        fillVertices(vertices);
+
+        guDrawVertices(vertices);
+
+        if (_buffer->getSourceWidth() > 512) {
+                setMaxTextureOffsetByIndex(1, 0);
+
+                guLoadTexture();
+                
+                vertices = guGetVertices();
+                fillVertices(vertices);
+
+                guDrawVertices(vertices);
+        }
+        
+        DEBUG_EXIT_FUNC();
+}
+
+INLINE void GuRenderer::setMaxTextureOffsetByIndex(uint32 x, uint32 y) { 
+        DEBUG_ENTER_FUNC();
+        const uint32 maxTextureSizeShift = 9; /* corresponds to 512 = max texture size*/
+
+        _maxTextureOffset.x = x << maxTextureSizeShift; /* x times 512 */
+        _maxTextureOffset.y = y << maxTextureSizeShift; /* y times 512 */
+        DEBUG_EXIT_FUNC();
+}
+
+INLINE void GuRenderer::guProgramDrawBehavior() {
+        DEBUG_ENTER_FUNC();
+        PSP_DEBUG_PRINT("blending[%s] colorTest[%s] reverseAlpha[%s] keyColor[%u]\n", _blending ? "on" : "off", _colorTest ? "on" : "off", _alphaReverse ? "on" : "off", _keyColor);
+        
+        if (_blending) {
+                sceGuEnable(GU_BLEND);
+
+                if (_alphaReverse)      // Reverse the alpha value (0 is 1)
+                        sceGuBlendFunc(GU_ADD, GU_ONE_MINUS_SRC_ALPHA, GU_SRC_ALPHA, 0, 0);
+                else    // Normal alpha values
+                        sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0);             
+
+        } else 
+                sceGuDisable(GU_BLEND);
+        
+        if (_colorTest) {
+                sceGuEnable(GU_COLOR_TEST);
+                sceGuColorFunc(GU_NOTEQUAL, _keyColor, 0x00ffffff);
+        } else
+                sceGuDisable(GU_COLOR_TEST);
+
+        DEBUG_EXIT_FUNC();
+}
+
+INLINE void GuRenderer::guLoadPalette() {
+        DEBUG_ENTER_FUNC();
+        
+        uint32 mask;
+        
+        if (_buffer->getBitsPerPixel() == 4)
+                mask = 0x0F;
+        else if (_buffer->getBitsPerPixel() == 8)
+                mask = 0xFF;
+        else
+                assert(0);      /* error */
+
+        PSP_DEBUG_PRINT("numOfEntries[%d]\n", _palette->getNumOfEntries());
+        PSP_DEBUG_PRINT("bpp[%d], pixelformat[%d], mask[%x]\n", _buffer->getBitsPerPixel(), _palette->getPixelFormat(), mask); 
+                
+        sceGuClutMode(convertToGuPixelFormat(_palette->getPixelFormat()), 0, mask, 0);
+        sceGuClutLoad(_palette->getNumOfEntries() >> 3, _palette->getRawValues());
+        
+        DEBUG_EXIT_FUNC();
+}
+
+INLINE void GuRenderer::guProgramTextureFormat() {
+        DEBUG_ENTER_FUNC();
+        PSP_DEBUG_PRINT("pixelFormat[%d]\n", _buffer->getPixelFormat());
+        
+        sceGuTexMode(convertToGuPixelFormat(_buffer->getPixelFormat()), 0, 0, 0);
+        DEBUG_EXIT_FUNC();
+}
+
+INLINE uint32 GuRenderer::convertToGuPixelFormat(PSPPixelFormat::Type format) { 
+                DEBUG_ENTER_FUNC();
+                
+                uint32 guFormat = 0;
+                
+                switch (format) {
+                case PSPPixelFormat::Type_4444:
+                        guFormat = GU_PSM_4444;
+                        break;
+                case PSPPixelFormat::Type_5551:
+                        guFormat = GU_PSM_5551;
+                        break;
+                case PSPPixelFormat::Type_5650:
+                        guFormat = GU_PSM_5650;
+                        break;
+                case PSPPixelFormat::Type_8888:
+                        guFormat = GU_PSM_8888;
+                        break;
+                case PSPPixelFormat::Type_Palette_8bit:
+                        guFormat = GU_PSM_T8;
+                        break;
+                case PSPPixelFormat::Type_Palette_4bit:
+                        guFormat = GU_PSM_T4;
+                        break;
+                default:
+                        break;                  
+        }
+        
+        PSP_DEBUG_PRINT("Pixelformat[%d], guFormat[%d]\n", format, guFormat);
+        
+        DEBUG_EXIT_FUNC();
+        return guFormat;
+        
+}
+
+INLINE void GuRenderer::guLoadTexture() {
+        DEBUG_ENTER_FUNC();
+        
+        sceGuTexImage(0, _buffer->getTextureWidth(), _buffer->getTextureHeight(), _buffer->getWidth(), _buffer->getPixels() + _buffer->_pixelFormat.pixelsToBytes(_maxTextureOffset.x));
+        
+        DEBUG_EXIT_FUNC();
+}
+
+INLINE Vertex *GuRenderer::guGetVertices() {
+        DEBUG_ENTER_FUNC();
+        
+        Vertex *ret = (Vertex *)sceGuGetMemory(2 * sizeof(Vertex));
+        
+        DEBUG_EXIT_FUNC();
+        return ret;
+}
+
+// Fills the vertices. Most of the logic is here.
+void GuRenderer::fillVertices(Vertex *vertices) {
+        DEBUG_ENTER_FUNC();
+        
+        uint32 outputWidth = _displayManager->getOutputWidth();
+        uint32 outputHeight = _displayManager->getOutputHeight();
+
+        float textureStartX, textureStartY, textureEndX, textureEndY;
+        
+        // Texture adjustments for eliminating half-pixel artifacts from scaling
+        // Not necessary if we don't scale
+        float textureAdjustment = 0.0f;
+        if (_useGlobalScaler && 
+           (_displayManager->getScaleX() != 1.0f || _displayManager->getScaleX() != 1.0f))
+                        textureAdjustment = 0.5f;
+        
+        textureStartX = textureAdjustment + _offsetInBuffer.x; //debug
+        textureStartY = textureAdjustment + _offsetInBuffer.y;
+        // We subtract maxTextureOffset because our shifted texture starts at 512 and will go to 640
+        textureEndX = _offsetInBuffer.x + _drawSize.width - textureAdjustment - _maxTextureOffset.x;
+        textureEndY = _offsetInBuffer.y + _drawSize.height - textureAdjustment;
+
+        // For scaling to the final image size, calculate the gaps on both sides
+        uint32 gapX = _useGlobalScaler ? (PSP_SCREEN_WIDTH - outputWidth) >> 1 : 0;
+        uint32 gapY = _useGlobalScaler ? (PSP_SCREEN_HEIGHT - outputHeight) >> 1 : 0;
+        
+        float imageStartX, imageStartY, imageEndX, imageEndY;
+
+        imageStartX = gapX + ( scaleSourceToOutputX(_maxTextureOffset.x) );
+        imageStartY = gapY;
+
+        imageStartX += scaleSourceToOutputX(_offsetOnScreen.x);
+        imageStartY += scaleSourceToOutputY(_offsetOnScreen.y);
+        
+        if (_fullScreen) { // shortcut
+                imageEndX = PSP_SCREEN_WIDTH - gapX;
+                imageEndY = PSP_SCREEN_HEIGHT - gapY;
+        } else { /* !fullScreen */
+                imageEndX = imageStartX + scaleSourceToOutputX(_drawSize.width);
+                imageEndY = imageStartY + scaleSourceToOutputY(_drawSize.height);
+        }
+
+        vertices[0].u = textureStartX;
+        vertices[0].v = textureStartY;
+        vertices[1].u = textureEndX;
+        vertices[1].v = textureEndY;
+        
+        vertices[0].x = imageStartX;
+        vertices[0].y = imageStartY;
+        vertices[0].z = 0;
+        vertices[1].x = imageEndX;
+        vertices[1].y = imageEndY;
+        vertices[1].z = 0;
+        
+        PSP_DEBUG_PRINT("TextureStart: X[%f] Y[%f] TextureEnd: X[%.1f] Y[%.1f]\n", textureStartX, textureStartY, textureEndX, textureEndY);
+        PSP_DEBUG_PRINT("ImageStart:   X[%f] Y[%f] ImageEnd:   X[%.1f] Y[%.1f]\n", imageStartX, imageStartY, imageEndX, imageEndY);
+        
+        DEBUG_EXIT_FUNC();
+}
+
+/* Scale the input X offset to appear in proper position on the screen */
+INLINE float GuRenderer::scaleSourceToOutputX(float offset) {
+        float result;
+        
+        if (!_useGlobalScaler)
+                result = offset;
+        else if (!offset)
+                result = 0.0f;  
+        else
+                result = offset * _displayManager->getScaleX();
+        
+        return result;
+}
+
+/* Scale the input Y offset to appear in proper position on the screen */
+INLINE float GuRenderer::scaleSourceToOutputY(float offset) {
+        float result;
+        
+        if (!_useGlobalScaler)
+                result = offset;
+        else if (!offset)
+                result = 0.0f;
+        else 
+                result = offset * _displayManager->getScaleY();
+                
+        return result;
+}
+
+INLINE void GuRenderer::guDrawVertices(Vertex *vertices) {
+        DEBUG_ENTER_FUNC();
+        
+        sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2, 0, vertices);
+        DEBUG_EXIT_FUNC();
+}
+
+void GuRenderer::cacheInvalidate(void *pointer, uint32 size) {
+        sceKernelDcacheWritebackInvalidateRange(pointer, size);
+}

backends/platform/psp/trace.h

@@ -29 +29 @@
 
 #include <stdio.h>
 #include <psptypes.h>
-#include <pspkernel.h>
 #include <stdarg.h>
-#include <pspdebug.h>
 
 // Use these defines for debugging
 
-//#define __PSP_DEBUG__
-//#define __PSP_DEBUG_SUSPEND__
+//#define __PSP_PRINT_TO_FILE__
+//#define __PSP_PRINT_TO_FILE_AND_SCREEN__
+//#define __PSP_DEBUG_FUNCS__   /* can put this locally too */
+//#define __PSP_DEBUG_PRINT__
 
-void PSPDebugTrace (const char *filename, const char *format, ...);
-void PSPDebugTrace (const char *format, ...);
+void PSPDebugTrace (bool alsoToScreen, const char *format, ...);
 
-#ifdef __PSP_DEBUG_SUSPEND__
-#define PSPDebugSuspend(format,...)             PSPDebugTrace(format, ## __VA_ARGS__)
-#else
-#define PSPDegbugSuspend(x)
-#define PSPDebugSuspend(format,...)
-#endif /* __PSP_DEBUG_SUSPEND__ */
+#ifndef TRACE_C
+extern int psp_debug_indent;
+#endif
 
+#endif /* TRACE_H */
 
-#endif // TRACE_H
+// From here on, we allow multiple definitions
+#undef __PSP_PRINT__
+#undef PSP_ERROR
+#undef __PSP_INDENT__
+#undef PSP_INFO_PRINT
+#undef PSP_INFO_PRINT_INDENT
+#undef PSP_DEBUG_PRINT
+#undef PSP_DEBUG_PRINT_FUNC
+#undef PSP_DEBUG_PRINT_SAMELN
+#undef PSP_DEBUG_DO
+#undef DEBUG_ENTER_FUNC
+#undef DEBUG_EXIT_FUNC
+#undef INLINE
 
+/* Choose to print to file/screen/both */
+#ifdef __PSP_PRINT_TO_FILE__
+        #define __PSP_PRINT__(format,...)                       PSPDebugTrace(false, format, ## __VA_ARGS__)
+#elif defined __PSP_PRINT_TO_FILE_AND_SCREEN__
+        #define __PSP_PRINT__(format,...)                       PSPDebugTrace(true, format, ## __VA_ARGS__)
+#else /* default - print to screen */
+        #define __PSP_PRINT__(format,...)                       fprintf(stderr, format, ## __VA_ARGS__)
+#endif /* PSP_PRINT_TO_FILE/SCREEN */
+        
+/* Error function */
+#define PSP_ERROR(format,...)                                   __PSP_PRINT__("Error in %s: " format, __PRETTY_FUNCTION__, ## __VA_ARGS__)
+
+/* Do the indent */
+#define __PSP_INDENT__                                                  for(int _i=psp_debug_indent; _i>0; _i--) \
+                                                                                                        __PSP_PRINT__( "   ") 
+
+/* always print */
+#define PSP_INFO_PRINT(format,...)                              __PSP_PRINT__(format, ## __VA_ARGS__)
+/* always print, with indent */
+#define PSP_INFO_PRINT_INDENT(format,...)               { __PSP_INDENT__; \
+                                                                                                __PSP_PRINT__(format, ## __VA_ARGS__); }
+
+#ifdef __PSP_DEBUG_PRINT__
+        /* printf with indents */
+        #define PSP_DEBUG_PRINT_SAMELN(format,...)      __PSP_PRINT__(format, ## __VA_ARGS__)
+        #define PSP_DEBUG_PRINT(format,...)                     { __PSP_INDENT__; \
+                                                                                                __PSP_PRINT__(format, ## __VA_ARGS__); }
+        #define PSP_DEBUG_PRINT_FUNC(format,...)        { __PSP_INDENT__; \
+                                                                                                __PSP_PRINT__("In %s: " format, __PRETTY_FUNCTION__, ## __VA_ARGS__); }
+        #define PSP_DEBUG_DO(x)                                         (x)                                             
+
+#else   /* no debug print */
+        #define PSP_DEBUG_PRINT_SAMELN(format,...)
+        #define PSP_DEBUG_PRINT(format,...)     
+        #define PSP_DEBUG_PRINT_FUNC(format,...)
+        #define PSP_DEBUG_DO(x) 
+#endif /* __PSP_DEBUG_PRINT__ */
+
+/* Debugging function calls */
+#ifdef __PSP_DEBUG_FUNCS__
+        #define DEBUG_ENTER_FUNC()                                      PSP_INFO_PRINT_INDENT("++ %s\n", __PRETTY_FUNCTION__); \
+                                                                                                psp_debug_indent++ 
+                                                        
+        #define DEBUG_EXIT_FUNC()                                       psp_debug_indent--; \
+                                                                                                if (psp_debug_indent < 0) PSP_ERROR("debug indent < 0\n"); \
+                                                                                                PSP_INFO_PRINT_INDENT("-- %s\n", __PRETTY_FUNCTION__)
+
+        #define INLINE                  /* don't want to inline so we get function names properly */
+                                                        
+#else /* Don't debug function calls */
+        #define DEBUG_ENTER_FUNC()
+        #define DEBUG_EXIT_FUNC()
+        #define INLINE                                          inline
+#endif /* __PSP_DEBUG_FUNCS__ */
+
+// Undef the main defines for next time
+#undef __PSP_PRINT_TO_FILE__
+#undef __PSP_PRINT_TO_FILE_AND_SCREEN__
+#undef __PSP_DEBUG_FUNCS__
+#undef __PSP_DEBUG_PRINT__

backends/platform/psp/display_manager.h

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $
+ * $Id: osys_psp.cpp 47541 2010-01-25 01:39:44Z lordhoto $
+ *
+ */
+
+#ifndef PSP_DISPLAY_MAN_H
+#define PSP_DISPLAY_MAN_H 
+
+/**
+ *      Class used only by DisplayManager to start/stop GU rendering
+ */
+class MasterGuRenderer {
+public:
+        MasterGuRenderer() : _lastRenderTime(0) {}
+        void guInit();
+        void guPreRender();
+        void guPostRender();
+        void guShutDown();
+private:
+        static uint32 _displayList[];
+        uint32 _lastRenderTime;                                 // For measuring rendering
+        void guProgramDisplayBufferSizes();
+};
+
+class Screen;
+class Overlay;
+class Cursor;
+class PSPKeyboard;
+
+/**
+ *      Class that manages all display clients
+ */
+class DisplayManager {
+public:
+        enum GraphicsModeID {                   ///> Possible output formats onscreen
+                CENTERED_320X200,
+                CENTERED_435X272,
+                STRETCHED_480X272,
+                CENTERED_362X272
+        };
+        DisplayManager() : _screen(0), _cursor(0), _overlay(0), _keyboard(0), _lastUpdateTime(0), _graphicsMode(0) {}
+        ~DisplayManager();
+        
+        void init();
+        void renderAll();
+        bool setGraphicsMode(int mode);
+        bool setGraphicsMode(const char *name);
+        int getGraphicsMode() const { return _graphicsMode; }
+    uint32 getDefaultGraphicsMode() const { return STRETCHED_480X272; }
+        const OSystem::GraphicsMode* getSupportedGraphicsModes() const { return _supportedModes; }
+
+        // Setters
+        void setScreen(Screen *screen) { _screen = screen; }
+        void setCursor(Cursor *cursor) { _cursor = cursor; }
+        void setOverlay(Overlay *overlay) { _overlay = overlay; }
+        void setKeyboard(PSPKeyboard *keyboard) { _keyboard = keyboard; }
+        void setSizeAndPixelFormat(uint width, uint height, const Graphics::PixelFormat *format);
+
+        // Getters
+        float getScaleX() { return _displayParams.scaleX; }
+        float getScaleY() { return _displayParams.scaleY; }
+        uint32 getOutputWidth() { return _displayParams.screenOutput.width; }
+        uint32 getOutputHeight() { return _displayParams.screenOutput.height; }
+        uint32 getOutputBitsPerPixel() { return _displayParams.outputBitsPerPixel; }
+        Common::List<Graphics::PixelFormat> getSupportedPixelFormats();
+
+private:
+        struct GlobalDisplayParams {
+                Dimensions screenOutput;
+                Dimensions screenSource;
+                float scaleX;
+                float scaleY;
+                uint32 outputBitsPerPixel;              // How many bits end up on-screen
+                GlobalDisplayParams() : scaleX(0.0f), scaleY(0.0f), outputBitsPerPixel(0) {}
+        };
+
+        // Pointers to DisplayClients
+        Screen *_screen;
+        Cursor *_cursor;
+        Overlay *_overlay;
+        PSPKeyboard *_keyboard;
+        
+        MasterGuRenderer _masterGuRenderer;
+        uint32 _lastUpdateTime;                                 // For limiting FPS
+        int _graphicsMode;
+        GlobalDisplayParams _displayParams;
+        static const OSystem::GraphicsMode _supportedModes[];
+        
+        void calculateScaleParams();    // calculates scaling factor
+        bool isTimeToUpdate();                  // should we update the screen now      
+};
+
+
+#endif /* PSP_DISPLAY_MAN_H */

backends/platform/psp/psp_main.cpp

@@ -26 +26 @@
 #define USERSPACE_ONLY  //don't use kernel mode features
 
 #ifndef USERSPACE_ONLY
-#include <pspkernel.h>
-#include <pspdebug.h>
+        #include <pspkernel.h>
+        #include <pspdebug.h>
+#else
+        #include <pspuser.h>
 #endif
 
 #include <psppower.h>
@@ -118 +120 @@
         cbid = sceKernelCreateCallback("Power Callback", (SceKernelCallbackFunction)power_callback, 0);
         if (cbid >= 0) {
                 if (scePowerRegisterCallback(-1, cbid) < 0) {
-                        PSPDebugTrace("SetupCallbacks(): Couldn't register callback for power_callback\n");
+                        PSP_ERROR("Couldn't register callback for power_callback\n");
                 }
         } else {
-                PSPDebugTrace("SetupCallbacks(): Couldn't create a callback for power_callback\n");
+                PSP_ERROR("Couldn't create a callback for power_callback\n");
         }
 
         sceKernelSleepThreadCB();
@@ -167 +169 @@
 
         return res;
 }
-

backends/platform/psp/memory.cpp

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $
+ * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $
+ *
+ */
+
+#include "common/scummsys.h" 
+#include "common/singleton.h"
+#include "common/list.h"
+#include "backends/platform/psp/psppixelformat.h"
+#include "backends/platform/psp/memory.h"
+ 
+// Class Copier --------------------------------------------------------------------------
+//#define __PSP_DEBUG_FUNCS__   /* For debugging the stack */
+//#define __PSP_DEBUG_PRINT__
+
+#include "backends/platform/psp/trace.h"
+
+void Copier::copy(byte *dst, const byte *src, uint32 bytes, PSPPixelFormat *format /* = NULL */) {
+        DEBUG_ENTER_FUNC();
+        
+        uint32 prefixDst = (((uint32)dst) & 0x3);
+        prefixDst = prefixDst ? 4 - prefixDst : 0;      // prefix only if we have address % 4 != 0
+        uint32 prefixSrc = (((uint32)src) & 0x3);
+        prefixSrc = prefixSrc ? 4 - prefixSrc : 0;  // prefix only if we have address % 4 != 0
+        uint32 *dst32, *src32;
+        bool swapRB = format ? format->swapRB : false;  // take swap value from pixelformat if it's given
+#ifdef __PSP_DEBUG_PRINT__
+        uint32 debugBytes = bytes;
+        const byte *debugDst = dst, *debugSrc = src;
+#endif  
+        uint32 words, remainingBytes;
+        
+        //PSP_DEBUG_PRINT("dst[%p], src[%p], bytes[%d], swap[%s], prefixDst[%u], prefixSrc[%u]\n", dst, src, bytes, swapRB ? "true" : "false", prefixDst, prefixSrc);
+        
+        if (prefixDst || prefixSrc) {                   // we're not aligned to word boundaries
+                if (prefixDst != prefixSrc) {           // worst case: we can never be aligned. this mode is highly inefficient. try to get engines not to use this mode too much
+                        PSP_DEBUG_PRINT("misaligned copy of %u bytes from %p to %p\n", bytes, src, dst);
+                        if ((prefixDst & 1) || (prefixSrc & 1))
+                                copy8(dst, src, bytes); // no swap is possible on 8 bit
+                        else
+                                copy16((uint16 *)dst, (uint16 *)src, bytes, format);
+                                
+                        goto test;      
+                }
+                
+                // Do the prefix: the part to get us aligned
+                if (prefixDst & 1) {                    // byte
+                        copy8(dst, src, prefixDst);     // no swap available
+                } else {                                                // short
+                        copy16((uint16 *)dst, (uint16 *)src, prefixDst, format);
+                }
+                if (bytes > prefixDst)  // check that we can afford to subtract from bytes
+                        bytes -= prefixDst;
+                else {
+                        DEBUG_EXIT_FUNC();      
+                        return;
+                }
+                dst32 = (uint32 *)(dst + prefixDst);
+                src32 = (uint32 *)(src + prefixSrc);
+        } else { // We're aligned to word boundaries
+                dst32 = (uint32 *)dst;
+                src32 = (uint32 *)src;
+        }       
+        
+        words = bytes >> 2;
+        remainingBytes = bytes & 0x3;
+        
+        if (swapRB) {   // need to swap
+                for (; words > 0; words--) {
+                        *dst32 = format->swapRedBlue32(*src32);
+                        dst32++;
+                        src32++;
+                }
+        } else { // no swapping
+                for (; words > 0; words--) {
+                        *dst32 = *src32;
+                        dst32++;
+                        src32++;
+                }
+        }
+
+        // Do any remaining bytes
+        if (remainingBytes) {
+                if (remainingBytes & 1) // we have bytes left
+                        copy8((byte *)dst32, (byte *)src32, remainingBytes);
+                else // 16bits left
+                        copy16((uint16*)dst32, (uint16 *)src32, remainingBytes, format);
+        }
+
+test:   
+        // debug
+#ifdef __PSP_DEBUG_PRINT__
+        bool mismatch = false;
+
+        for (uint32 i=0; i<debugBytes; i++) {
+                if (debugDst[i] != debugSrc[i]) { 
+                        if (mismatch == false) {
+                                PSP_DEBUG_PRINT_SAMELN("mismatch in copy:\n");
+                                PSP_DEBUG_PRINT("dst[%p], src[%p], bytes[%u], swap[%s], prefixDst[%u], prefixSrc[%u]\n", debugDst, debugSrc, debugBytes, swapRB ? "true" : "false", prefixDst, prefixSrc);
+                                mismatch = true;
+                        }
+                        PSP_DEBUG_PRINT_SAMELN("%x!=%x ", debugSrc[i], debugDst[i]);
+                }
+        }
+        if (mismatch) 
+                PSP_DEBUG_PRINT("\n");
+#endif
+
+        DEBUG_EXIT_FUNC();
+}
+
+inline void Copier::copy8(byte *dst, const byte *src, uint32 bytes) {
+        for (; bytes > 0; bytes--) {
+                *dst = *src;
+                dst++;
+                src++;
+        }       
+}
+
+inline void Copier::copy16(uint16 *dst, const uint16 *src, uint32 bytes, PSPPixelFormat *format /* = NULL */) {
+        uint32 shorts = bytes >> 1;
+        uint32 remainingBytes = bytes & 1;
+        bool swapRB = format ? format->swapRB : false;
+
+        if (swapRB) {
+                for (; shorts > 0 ; shorts--) {
+                        *dst = format->swapRedBlue16(*src);
+                        dst++;
+                        src++;
+                }       
+        } else {
+                for (; shorts > 0 ; shorts--) {
+                        *dst = *src;
+                        dst++;
+                        src++;
+                }
+        }
+        if (remainingBytes)
+                *(byte *)dst = *(byte *)src;
+}
+ 
+ 
+// Class VramAllocator -----------------------------------
+
+DECLARE_SINGLETON(VramAllocator)
+
+//#define __PSP_DEBUG_FUNCS__   /* For debugging the stack */
+//#define __PSP_DEBUG_PRINT__
+
+#include "backends/platform/psp/trace.h"
+
+
+void *VramAllocator::allocate(int32 size, bool smallAllocation /* = false */) {
+        DEBUG_ENTER_FUNC();
+        assert (size > 0);
+        
+        byte *lastAddress = smallAllocation ? (byte *)VRAM_SMALL_ADDRESS : (byte *)VRAM_START_ADDRESS;
+        Common::List<Allocation>::iterator i;
+
+        // Find a block that fits, starting from the beginning
+        for (i = _allocList.begin(); i != _allocList.end(); ++i) {
+                byte *currAddress = (*i).address;
+                
+                if (currAddress - lastAddress >= size) // We found a match
+                        break;
+                
+                if ((*i).getEnd() > lastAddress)
+                        lastAddress = (byte *)(*i).getEnd();
+        }
+
+        if (lastAddress + size > (byte *)VRAM_END_ADDRESS) {
+                PSP_DEBUG_PRINT("No space for allocation of %d bytes. %d bytes already allocated.\n",
+                                                size, _bytesAllocated);
+                return NULL;
+        }
+
+        _allocList.insert(i, Allocation(lastAddress, size));
+        _bytesAllocated += size;
+        
+        PSP_DEBUG_PRINT("Allocated in VRAM, size %u at %p.\n", size, lastAddress);
+        PSP_DEBUG_PRINT("Total allocated %u, remaining %u.\n", _bytesAllocated, (2 * 1024 * 1024) - _bytesAllocated);
+        
+        DEBUG_EXIT_FUNC();
+        return lastAddress;
+}
+
+// Deallocate a block from VRAM
+void VramAllocator::deallocate(void *address) {
+        DEBUG_ENTER_FUNC();
+        address = (byte *)CACHED(address);      // Make sure all addresses are the same
+        
+        Common::List<Allocation>::iterator i;
+        
+        // Find the Allocator to deallocate
+        for (i = _allocList.begin(); i != _allocList.end(); ++i) {
+                if ((*i).address == address) {
+                        _bytesAllocated -= (*i).size;
+                        _allocList.erase(i);
+                        PSP_DEBUG_PRINT("Deallocated address[%p], size[%u]\n", (*i).address, (*i).size);
+                        DEBUG_EXIT_FUNC();
+                        return;
+                }
+        }       
+        
+        PSP_DEBUG_PRINT("Address[%p] not allocated.\n", address);
+        DEBUG_EXIT_FUNC();
+}               

backends/platform/psp/module.mk

@@ -1 +1 @@
 MODULE := backends/platform/psp
 
-MODULE_OBJS := \
-        powerman.o \
+MODULE_OBJS := powerman.o \
         psp_main.o \
         osys_psp.o \
+        psppixelformat.o \
+        memory.o \
+        display_manager.o \
+        display_client.o \
+        default_display_client.o \
+        input.o \
+        cursor.o \
         trace.o \
         psploader.o \
         pspkeyboard.o

backends/platform/psp/default_display_client.h

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/trace.h $
+ * $Id: trace.h 44276 2009-09-23 16:11:23Z joostp $
+ *
+ */
+
+#ifndef PSP_DEF_DISPLAY_CLIENT_H
+#define PSP_DEF_DISPLAY_CLIENT_H 
+
+/**
+ *      Default display client that is useful for most purposes.
+ */
+class DefaultDisplayClient : public DisplayClient {
+public:
+        DefaultDisplayClient() : _visible(false), _dirty(true) {}
+        
+        bool isVisible() { return _visible; }
+        void setVisible(bool v) { _visible = v; setDirty(); }
+        Buffer &buffer() { return _buffer; }
+        Palette &palette() { return _palette; }
+        void init();
+        bool allocate(bool bufferInVram = false, bool paletteInVram = false);
+        void deallocate();
+        void clearBuffer();
+        void clearPalette();
+        void render() { _renderer.render(); }
+        uint32 getWidth() { return _buffer.getSourceWidth(); }
+        uint32 getHeight() { return _buffer.getSourceHeight(); }
+        void setPartialPalette(const byte *colors, uint start, uint num) { setDirty(); return _palette.setPartial(colors, start, num); }
+        void getPartialPalette(byte *colors, uint start, uint num) { 
+                return _palette.getPartial(colors, start, num); 
+        }
+        void copyFromRect(const byte *buf, int pitch, int destX, int destY, int recWidth, int recHeight);
+        void copyToArray(byte *dst, int pitch);
+        void setDirty() { _dirty = true; }
+        void setClean() { _dirty = false; }
+        bool isDirty() { return _dirty; }
+
+protected:
+        Buffer _buffer;
+        Palette _palette;
+        GuRenderer _renderer;
+        bool _visible;
+        bool _dirty;
+};
+
+/**
+ *      Screen overlay class.
+ */
+class Overlay : public DefaultDisplayClient {
+public:
+        Overlay() {}
+        ~Overlay() { }
+        
+        void init();
+        bool allocate();
+        void setBytesPerPixel(uint32 size);
+        void setSize(uint32 width, uint32 height);
+        void copyToArray(OverlayColor *buf, int pitch);
+        void copyFromRect(const OverlayColor *buf, int pitch, int x, int y, int w, int h);      
+};
+
+/**
+ *      Screen class.
+ */
+class Screen : public DefaultDisplayClient {
+public:
+        Screen() : _shakePos(0) {
+                memset(&_pixelFormat, 0, sizeof(_pixelFormat));
+                memset(&_frameBuffer, 0, sizeof(_frameBuffer));
+        }
+        ~Screen() {}
+        
+        void init();
+        bool allocate();
+        void setShakePos(int pos);
+        void setScummvmPixelFormat(const Graphics::PixelFormat *format);
+        const Graphics::PixelFormat &getScummvmPixelFormat() const { return _pixelFormat; }
+        Graphics::Surface *lockAndGetForEditing();
+        void unlock() { setDirty(); } // set dirty here because of changes 
+        void setSize(uint32 width, uint32 height);      
+        
+private:
+        uint32 _shakePos;
+        Graphics::PixelFormat _pixelFormat;
+        Graphics::Surface _frameBuffer;
+};
+
+#endif /* PSP_DEF_DISPLAY_CLIENT_H */

backends/platform/psp/cursor.cpp

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.h $
+ * $Id: osys_psp.h 46120 2009-11-24 10:33:30Z Bluddy $
+ *
+ */
+
+#include "common/scummsys.h"
+#include "backends/platform/psp/display_client.h"
+#include "backends/platform/psp/default_display_client.h"
+#include "backends/platform/psp/cursor.h"
+
+//#define __PSP_DEBUG_FUNCS__   /* For debugging the stack */
+//#define __PSP_DEBUG_PRINT__ 
+
+#include "backends/platform/psp/trace.h" 
+ 
+void Cursor::init() {
+        DEBUG_ENTER_FUNC();
+        
+        _renderer.setBuffer(&_buffer);                  // We do this explicitly
+        _renderer.setPalette(&_screenPalette);  // because we want to choose screenpalette by default
+        _renderer.setUseGlobalScaler(true);
+        setRendererModePalettized(true);                // Assume we start in 8bit mode
+        
+        // Default modes
+        _palette.setPixelFormats(PSPPixelFormat::Type_5551, PSPPixelFormat::Type_Palette_8bit); // default
+        _screenPalette.setPixelFormats(PSPPixelFormat::Type_5551, PSPPixelFormat::Type_Palette_8bit);
+        _buffer.setPixelFormat(PSPPixelFormat::Type_5551);
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void Cursor::deallocate() {
+        DEBUG_ENTER_FUNC();
+        
+        _buffer.deallocate();
+        _palette.deallocate();
+        _screenPalette.deallocate();
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void Cursor::setCursorPalette(const byte *colors, uint start, uint num) {
+        DEBUG_ENTER_FUNC();
+
+        if (!_palette.isAllocated()) {
+                _palette.allocate();
+        }
+        
+        // Workaround: This is wrong, but we seem to not be getting setScreenPalette
+        if (!_screenPalette.isAllocated()) {
+                _screenPalette.allocate();
+        }       
+        
+        _palette.setPartial(colors, start, num);
+        setDirty();
+        
+        DEBUG_EXIT_FUNC();
+}       
+
+void Cursor::setScreenPalette(const byte *colors, uint start, uint num) {
+        DEBUG_ENTER_FUNC();
+
+        if (!_screenPalette.isAllocated()) {
+                _screenPalette.allocate();
+        }
+        
+        _screenPalette.setPartial(colors, start, num);
+        setDirty();
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void Cursor::setKeyColor(uint32 color) {
+        DEBUG_ENTER_FUNC();
+        PSP_DEBUG_PRINT("new color[%u], old color[%u]\n", color, _keyColor);
+        
+        // If it's a different color, undo the last keycolor
+        if (_buffer.hasPalette() && color != _keyColor) {
+                if (_screenPalette.isAllocated())
+                        _screenPalette.setColorPositionAlpha(_keyColor, true);
+                if (_palette.isAllocated())
+                        _palette.setColorPositionAlpha(_keyColor, true);
+        }
+        // Don't need anything special for 16-bit
+        _keyColor = color;
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void Cursor::clearKeyColor() {
+        DEBUG_ENTER_FUNC();
+        PSP_DEBUG_PRINT("keyColor[%d]\n", _keyColor);
+
+        // We need 2 mechanisms: one for palettized and one for 16 bit
+        if (_buffer.hasPalette()) {
+                if (_screenPalette.isAllocated())
+                        _screenPalette.setColorPositionAlpha(_keyColor, false);         // set keycolor to 0    
+                if (_palette.isAllocated())
+                        _palette.setColorPositionAlpha(_keyColor, false);       
+        } else {        // 16bit
+                _renderer.setKeyColor(_keyColor);
+        }
+        setDirty();
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void Cursor::enableCursorPalette(bool enable) {
+        DEBUG_ENTER_FUNC();
+        PSP_DEBUG_PRINT("enable[%s]\n", enable ? "true" : "false");
+        
+        _useCursorPalette = enable;
+        if (enable)
+                _renderer.setPalette(&_palette);        // very important that we do this switch
+        else
+                _renderer.setPalette(&_screenPalette);
+        
+        setDirty();
+        DEBUG_EXIT_FUNC();              
+}
+
+inline void Cursor::setSize(uint32 width, uint32 height) {
+        DEBUG_ENTER_FUNC();
+        PSP_DEBUG_PRINT("width[%u], height[%u]\n", width, height);
+
+        _buffer.setSize(width, height, Buffer::kSizeByTextureSize);     // we'll use texture size for mouse
+        _renderer.setDrawWholeBuffer();         // We need to let the renderer know how much to draw
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void Cursor::copyFromArray(const byte *array) {
+        DEBUG_ENTER_FUNC();
+        
+        if (!_buffer.isAllocated())     {
+                _buffer.allocate();
+        }
+
+        _buffer.copyFromArray(array, _buffer.getSourceWidthInBytes());  // pitch is source width
+        setDirty();
+        
+        // debug        
+        //PSP_DEBUG_DO(_buffer.print(0xF));
+
+        DEBUG_EXIT_FUNC();
+
+}
+
+void Cursor::setHotspot(int32 x, int32 y) {
+        DEBUG_ENTER_FUNC();
+
+        _hotspotX = x;
+        _hotspotY = y;
+        updateRendererOffset(); // Important
+
+        PSP_DEBUG_PRINT("hotspotX[%d], hotspotY[%d]\n", x, y);
+        DEBUG_EXIT_FUNC();
+}
+
+// Returns true if change in x or y
+bool Cursor::increaseXY(int32 incX, int32 incY) {
+        DEBUG_ENTER_FUNC();     
+
+        int32 oldX = _x, oldY = _y;
+
+        // adjust for differences in X and Y
+        adjustXYForScreenSize(incX, incY);
+        
+        _x += incX;
+        _y += incY;
+        
+        // Clamp mouse
+        if (_x < 0)
+                _x = 0;
+        if (_y < 0)
+                _y = 0;
+        if (_x >= (int)_mouseLimitWidth)
+                _x = (int)_mouseLimitWidth - 1;
+        if (_y >= (int)_mouseLimitHeight)
+                _y = (int)_mouseLimitHeight - 1;
+        
+        PSP_DEBUG_PRINT("X[%d], Y[%d]\n", _x, _y);
+        
+        if (oldX != _x || oldY != _y) {
+                updateRendererOffset();
+                setDirty();
+                DEBUG_EXIT_FUNC();
+                return true;
+        }
+        
+        DEBUG_EXIT_FUNC();
+        return false;
+}
+
+// Set limits on the movement of the cursor ie. screen size
+void Cursor::setLimits(uint32 width, uint32 height) { 
+        #define PSP_SCREEN_WIDTH 480
+        #define PSP_SCREEN_HEIGHT 272
+        DEBUG_ENTER_FUNC();
+        
+        PSP_DEBUG_PRINT("width[%u], height[%u]\n", width, height);
+        _mouseLimitWidth = width; 
+        _mouseLimitHeight = height; 
+        
+        DEBUG_EXIT_FUNC();
+}
+        
+// Adjust X,Y movement for the screen size to keep it consistent        
+INLINE void Cursor::adjustXYForScreenSize(int32 &x, int32 &y) {
+        DEBUG_ENTER_FUNC();
+        // We have our speed calibrated for the y axis at 480x272. The idea is to adjust this for other
+        // resolutions and for x, which is wider.
+        int32 newX = x, newY = y;
+        
+        // adjust width movement to match height (usually around 1.5)
+        if (_mouseLimitWidth >= _mouseLimitHeight + (_mouseLimitHeight >> 1))
+                newX = newX + (newX >> 1);
+        
+        if (_mouseLimitWidth >= 600) {  // multiply by 2
+                newX <<= 1; 
+                newY <<= 1;
+        } else if (_mouseLimitWidth >= 480) {   // multiply by 1.5
+                newX = newX + (newX >> 1);
+                newY = newY + (newY >> 1);
+        }
+        
+        // Divide all movements by 8
+        newX >>= 3;
+        newY >>= 3;
+        
+        // Make sure we didn't destroy minimum movement 
+        if (!((x && !newX) || (y && !newY))) {  
+                x = newX;
+                y = newY;
+        }
+        
+        DEBUG_EXIT_FUNC();
+}
+
+// This is only called when we have a new screen
+void Cursor::setScreenPaletteScummvmPixelFormat(const Graphics::PixelFormat *format) {
+        DEBUG_ENTER_FUNC();
+
+        uint32 oldPaletteSize = 0;
+        if (_screenPalette.isAllocated())
+                oldPaletteSize = _screenPalette.getSizeInBytes();
+        
+        PSPPixelFormat::Type bufferType = PSPPixelFormat::Type_Unknown;
+        PSPPixelFormat::Type paletteType = PSPPixelFormat::Type_Unknown;
+        bool swapRedBlue = false;
+        
+        // Convert Scummvm Pixel Format to PSPPixelFormat
+        PSPPixelFormat::convertFromScummvmPixelFormat(format, bufferType, paletteType, swapRedBlue);
+        
+        if (paletteType == PSPPixelFormat::Type_None) {
+                //_screenPalette.deallocate();          // leave palette for default CLUT8
+                setRendererModePalettized(false);       // use 16-bit mechanism
+        } else {        // We have a palette
+                _screenPalette.setPixelFormats(paletteType, bufferType);        
+                _palette.setPixelFormats(paletteType, bufferType);              
+                setRendererModePalettized(true);        // use palettized mechanism
+        }
+        
+        DEBUG_EXIT_FUNC();
+}
+
+// This is called many many times
+void Cursor::setSizeAndScummvmPixelFormat(uint32 width, uint32 height, const Graphics::PixelFormat *format) {
+        DEBUG_ENTER_FUNC();
+        
+        PSP_DEBUG_PRINT("useCursorPalette[%s]\n", _useCursorPalette ? "true" : "false");
+        
+        uint32 oldBufferSize = 0, oldPaletteSize = 0;
+        
+        if (_buffer.isAllocated()) 
+                oldBufferSize = _buffer.getSizeInBytes();
+                
+        if (_palette.isAllocated())
+                oldPaletteSize = _palette.getSizeInBytes();
+        
+        setSize(width, height);
+        
+        PSPPixelFormat::Type bufferType = PSPPixelFormat::Type_Unknown;
+        PSPPixelFormat::Type paletteType = PSPPixelFormat::Type_Unknown;
+        bool swapRedBlue = false;
+        
+        PSPPixelFormat::convertFromScummvmPixelFormat(format, bufferType, paletteType, swapRedBlue);
+        PSP_DEBUG_PRINT("bufferType[%u], paletteType[%u]\n", bufferType, paletteType);
+        
+        // Check if we need to set new pixel format
+        if (_buffer.getPixelFormat() != bufferType) {
+                PSP_DEBUG_PRINT("new buffer pixel format[%u] is different from [%u]. Setting it.\n", bufferType, _buffer.getPixelFormat());
+                _buffer.setPixelFormat(bufferType);
+        }
+        
+        // Check if we need to reallocate
+        if (_buffer.getSizeInBytes() != oldBufferSize) {
+                _buffer.allocate();
+                PSP_DEBUG_PRINT("reallocating buffer. new size: width[%u], height[%u]\n", width, height);
+        }
+
+        PSP_DEBUG_PRINT("palette pixel format[%u]\n", paletteType);
+                
+        if (paletteType == PSPPixelFormat::Type_None) {
+                setRendererModePalettized(false);       // use palettized mechanism
+        } else {        // We have a palette
+                _palette.setPixelFormats(paletteType, bufferType);              
+                setRendererModePalettized(true);        // use palettized mechanism
+        }       
+
+        // debug
+        // PSP_DEBUG_DO(_palette.print(10));
+        // PSP_DEBUG_DO(_screenPalette.print(10));
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void Cursor::setXY(int x, int y) {
+        DEBUG_ENTER_FUNC(); 
+        
+    _x = x; 
+        _y = y; 
+        updateRendererOffset(); // Very important to let renderer know things changed
+        setDirty();
+        
+        DEBUG_EXIT_FUNC();
+}
+
+INLINE void Cursor::updateRendererOffset() {
+        DEBUG_ENTER_FUNC();
+        _renderer.setOffsetOnScreen(_x - _hotspotX, _y - _hotspotY);
+        DEBUG_EXIT_FUNC();
+}
+
+INLINE void Cursor::setRendererModePalettized(bool palettized) {
+        if (palettized) {       // We have a palette. Use blending
+                _renderer.setAlphaBlending(true);
+                _renderer.setAlphaReverse(false);
+                _renderer.setColorTest(false);
+        } else {                        // 16 bits, no palette
+                _renderer.setAlphaBlending(true);
+                _renderer.setAlphaReverse(true); // We can't change all alpha values, so just reverse
+                _renderer.setColorTest(true);   // Color test to make our key color transparent
+        }
+}

backends/platform/psp/psppixelformat.cpp

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $
+ * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $
+ *
+ */
+
+#include "common/scummsys.h" 
+#include "backends/platform/psp/psppixelformat.h" 
+
+//#define __PSP_DEBUG_FUNCS__   /* For debugging function calls */
+//#define __PSP_DEBUG_PRINT__   /* For debug printouts */
+
+#include "backends/platform/psp/trace.h"
+
+// class PSPPixelFormat --------------------------------------
+
+void PSPPixelFormat::set(Type type, bool swap /* = false */) {
+        DEBUG_ENTER_FUNC();
+        PSP_DEBUG_PRINT("type = %d\n", type);
+        
+        format = type;
+        swapRB = swap;
+        
+        switch (type) {
+        case Type_4444:
+        case Type_5551:
+        case Type_5650:
+                bitsPerPixel = 16;
+                break;
+        case Type_8888:
+                bitsPerPixel = 32;
+                break;
+        case Type_Palette_8bit:
+                bitsPerPixel = 8;
+                break;
+        case Type_Palette_4bit:
+                bitsPerPixel = 4;
+                break;
+        case Type_None:
+                bitsPerPixel = 0;
+                break;
+        default:        // This is an error, but let's continue anyway
+                PSP_ERROR("Unhandled value of pixel type[%d]\n", type);
+                bitsPerPixel = 16;
+                break;
+        }
+
+        PSP_DEBUG_PRINT("bitsPerPixel[%u]\n", bitsPerPixel);
+        DEBUG_EXIT_FUNC();
+}
+
+// Convert from ScummVM general PixelFormat to our pixel format
+// For buffer and palette.
+void PSPPixelFormat::convertFromScummvmPixelFormat(const Graphics::PixelFormat *pf,
+                                                                                                PSPPixelFormat::Type &bufferType,
+                                                                                                PSPPixelFormat::Type &paletteType,
+                                                                                                bool &swapRedBlue) {
+        swapRedBlue = false;     // no red-blue swap by default
+        PSPPixelFormat::Type *target = 0;       // which one we'll be filling
+        
+        if (!pf) {      // Default, pf is NULL
+                bufferType = Type_Palette_8bit;
+                paletteType = Type_5551;
+        } else {        // We have a pf
+                if (pf->bytesPerPixel == 1) {
+                        bufferType = Type_Palette_8bit;
+                        target = &paletteType;  // The type describes the palette
+                } else if (pf->bytesPerPixel == 2) {
+                        paletteType = Type_None;
+                        target = &bufferType;   // The type describes the buffer
+                } else {
+                        PSP_ERROR("Unknown bpp[%u] in pixeltype. Reverting to 8bpp\n", pf->bytesPerPixel);
+                        bufferType = Type_Palette_8bit;
+                        target = &paletteType;  // The type describes the palette
+                }
+        
+                // Find out the exact type of the target
+                if (pf->rLoss == 3 && pf->bLoss == 3) {
+                        if (pf->gLoss == 3)
+                                *target = Type_5551;
+                        else
+                                *target = Type_5650;
+                } else if (pf->rLoss == 4 && pf->gLoss == 4 && pf->bLoss == 4) {
+                        *target = Type_4444;
+                } else if (pf->gLoss == 0 && pf->gShift == 8) {
+                        *target = Type_8888;
+                } else if ((pf->gLoss == 0 && pf->gShift == 0) ||
+                                   (pf->gLoss == 8 && pf->gShift == 0)) {       // Default CLUT8 can have weird values
+                        *target = Type_5551;
+                } else {
+                        PSP_ERROR("Unknown Scummvm pixel format.\n");
+                        PSP_ERROR("\trLoss[%d], gLoss[%d], bLoss[%d], aLoss[%d]\n\trShift[%d], gShift[%d], bShift[%d], aShift[%d]\n",
+                        pf->rLoss, pf->gLoss, pf->bLoss, pf->aLoss,
+                        pf->rShift, pf->gShift, pf->bShift, pf->aShift);                
+                        *target = Type_Unknown;
+                }
+
+                if (pf->rShift != 0)    {// We allow backend swap of red and blue
+                        swapRedBlue = true;
+                        PSP_DEBUG_PRINT("detected red/blue swap\n");
+                }
+        }
+}
+
+Graphics::PixelFormat PSPPixelFormat::convertToScummvmPixelFormat(PSPPixelFormat::Type type) {
+        Graphics::PixelFormat pf;
+        
+        switch(type) {
+        case Type_4444:
+                pf.bytesPerPixel = 2;
+                pf.aLoss = 4;    pf.rLoss = 4;   pf.gLoss = 4;   pf.bLoss = 4;
+                pf.aShift = 12; pf.rShift = 0;  pf.gShift = 4;  pf.bShift = 8; 
+                break;
+        case Type_5551:
+                pf.bytesPerPixel = 2;
+                pf.aLoss = 7;    pf.rLoss = 3;    pf.gLoss = 3;    pf.bLoss = 3;
+                pf.aShift = 15; pf.rShift = 0;   pf.gShift = 5;   pf.bShift = 10; 
+                break;
+        case Type_5650:
+                pf.bytesPerPixel = 2;
+                pf.aLoss = 8;     pf.rLoss = 3;    pf.gLoss = 2;    pf.bLoss = 3;
+                pf.aShift = 0;   pf.rShift = 0;   pf.gShift = 5;   pf.bShift = 11; 
+                break;
+        case Type_8888:
+                pf.bytesPerPixel = 4;
+                pf.aLoss = 0;     pf.rLoss = 0;    pf.gLoss = 0;    pf.bLoss = 0;
+                pf.aShift = 24;  pf.rShift = 0;   pf.gShift = 8;   pf.bShift = 16; 
+                break;
+        default:
+                PSP_ERROR("Unhandled PSPPixelFormat[%u]\n", type);
+                break;
+        }
+        
+        return pf;
+}
+
+uint32 PSPPixelFormat::convertTo32BitColor(uint32 color) {
+        DEBUG_ENTER_FUNC();
+        uint32 r,g,b,a, output;
+        
+        colorToRgba(color, r, g, b, a);
+        output = ((b << 16) | (g << 8) | (r << 0) | (a << 24));
+        PSP_DEBUG_PRINT_FUNC("input color[%x], output[%x]\n", color, output);
+        
+        DEBUG_EXIT_FUNC();
+        return output;
+}

backends/platform/psp/pspkeyboard.cpp

@@ -24 +24 @@
  */
 
 //#define PSP_KB_SHELL  /* Need a hack to properly load the keyboard from the PSP shell */
+
 #ifdef PSP_KB_SHELL
-#define PSP_KB_SHELL_PATH       "ms0:/psp/game4xx/scummvm-1.0.0rc1/"    /* path to kbd.zip */
+        #define PSP_KB_SHELL_PATH       "ms0:/psp/game4xx/scummvm-solid/"       /* path to kbd.zip */
 #endif
-//#define PSP_KB_DEBUG
 
+//#define __PSP_DEBUG_FUNCS__   /* For debugging the stack */
+//#define __PSP_DEBUG_PRINT__
+
+#include "backends/platform/psp/trace.h"
 #include <malloc.h>
 #include "pspkernel.h"
-#include <pspgu.h>
 #include "png.h"
-#include "pspkeyboard.h"
+#include "backends/platform/psp/pspkeyboard.h"
 #include "common/keyboard.h"
 #include "common/fs.h"
 #include "common/unzip.h"
@@ -94 +97 @@
         file->read(data, length);
 }
 
+// Array with file names
+const char *PSPKeyboard::_guiStrings[] = {
+        "keys4.png", "keys_s4.png",
+        "keys_c4.png", "keys_s_c4.png",
+        "nums4.png", "nums_s4.png",
+        "syms4.png", "syms_s4.png"
+};
+
 // Constructor
 PSPKeyboard::PSPKeyboard() {
+        DEBUG_ENTER_FUNC();
+        
         _init = false;                  // we're not initialized yet
         _prevButtons = 0;               // Reset previous buttons
-        _dirty = true;          // keyboard needs redrawing
-        _mode = 0;              // charset selected. (0 - letters, 1 - uppercase 2 - numbers 3 - symbols)
+        _dirty = false;         // keyboard needs redrawing
+        _mode = 0;              // charset selected. (0: letters, 1: uppercase 2: numbers 3: symbols)
         _oldCursor = kCenter;   // Center cursor by default
-        _moved_x = 20;                  // Default starting location
-        _moved_y = 50;
+        _movedX = 20;                   // Default starting location
+        _movedY = 50;
         _moved = false;                 // Keyboard wasn't moved recently
         _state = kInvisible;    // We start invisible
         _lastState = kInvisible;
+        
+        // Constant renderer settings
+        _renderer.setAlphaBlending(true);
+        _renderer.setColorTest(false);
+        _renderer.setUseGlobalScaler(false);    
+        
+        DEBUG_EXIT_FUNC();
 }
 
 // Destructor
 PSPKeyboard::~PSPKeyboard() {
-        if (!_init) return;
+        DEBUG_ENTER_FUNC();
+        
+        if (!_init) {
+                DEBUG_EXIT_FUNC();
+                return;
+        }
 
-        int a;
-        for (a = 0; a < guiStringsSize; a++) {
-                free(_keyTextures[a].texture);
-                free(_keyTextures[a].palette);
-                _keyTextures[a].texture = NULL;
-                _keyTextures[a].palette = NULL;
+        for (int i = 0; i < guiStringsSize; i++) {
+                _buffers[i].deallocate();
+                _palettes[i].deallocate();
         }
         _init = false;
+        
+        DEBUG_EXIT_FUNC();
 }
 
-// Array with file names
-const char *PSPKeyboard::_guiStrings[] = {
-        "keys4.png", "keys_s4.png",
-        "keys_c4.png", "keys_s_c4.png",
-        "nums4.png", "nums_s4.png",
-        "syms4.png", "syms_s4.png"
-};
-
-// Defines for working with PSP buttons
-#define CHANGED(x)       (buttonsChanged & (x))
-#define PRESSED(x)   ((buttonsChanged & (x)) && (pad.Buttons & (x)))
-#define UNPRESSED(x) ((buttonsChanged & (x)) && !(pad.Buttons & (x)))
-#define DOWN(x)          (pad.Buttons & (x))
-#define UP(x)            (!(pad.Buttons & (x)))
-#define PSP_DPAD         (PSP_CTRL_DOWN|PSP_CTRL_UP|PSP_CTRL_LEFT|PSP_CTRL_RIGHT)
-#define PSP_4BUTTONS (PSP_CTRL_CROSS | PSP_CTRL_CIRCLE | PSP_CTRL_TRIANGLE | PSP_CTRL_SQUARE)
-
-/*
- *  Attempts to read a character from the controller
- *  Uses the state machine.
- */
-bool PSPKeyboard::processInput(Common::Event &event, SceCtrlData &pad, bool &usedInput) {
-        usedInput = false;                      // Assume we don't use an input
-        bool haveEvent = false;         // Whether we have an event for the event manager to process
-        event.kbd.flags = 0;
-        unsigned int keyDown;
-        uint32 buttonsChanged = _prevButtons ^ pad.Buttons;
-
-        if (!_init)                                     // In case we never had init
-                goto END;
-
-        if (PRESSED(PSP_CTRL_SELECT)) {
+void PSPKeyboard::setVisible(bool val) { 
+        if (val && _state == kInvisible && _init) {     // Check also that were loaded correctly
                 _lastState = _state;
-                _state = kMove;                 // Check for move or visible state
-                usedInput = true;
-                goto END;
+                _state = kMove; 
         }
-
-        if (_state == kInvisible)       // Return if we're invisible
-                goto END;
-
-        if (DOWN(PSP_DPAD | PSP_4BUTTONS | PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER | PSP_CTRL_START))
-                usedInput = true;               // for now, we neutralize all button inputs
-
-        // Check for moving the keyboard onscreen
-        if (_state == kMove) {
-                if (UNPRESSED(PSP_CTRL_SELECT)) {
-                        _state = (_lastState == kInvisible) ? kDefault : kInvisible;                    // Back to previous state
-                        _dirty = true;
-
-                        if (_moved) {                           // We moved the keyboard. Keep the keyboard onscreen
-                                _state = kDefault;
-                                _moved = false;                 // reset moved flag
-                        }
-                }
-                else if (DOWN(PSP_DPAD)) {
-                        _moved = true;
-                        _dirty = true;
-
-                        if (DOWN(PSP_CTRL_DOWN))
-                                increaseKeyboardLocationY(5);
-                        else if (DOWN(PSP_CTRL_UP))
-                                increaseKeyboardLocationY(-5);
-                        else if (DOWN(PSP_CTRL_LEFT))
-                                increaseKeyboardLocationX(-5);
-                        else  /* DOWN(PSP_CTRL_RIGHT) */
-                                increaseKeyboardLocationX(5);
-                }
-                usedInput = true;       // We used up the input (select was held down)
-                goto END;
+        else if ( !val && _state != kInvisible) {
+                _lastState = _state;
+                _state = kInvisible; 
         }
-
-
-        // Handle 4 buttons + 2 triggers
-        if (_state == kDefault || _state == kCornersSelected) {
-                unsigned int changed;
-
-                if (_state == kDefault) {       // Handle default state
-                        changed = CHANGED(PSP_4BUTTONS);                        // We only care about the 4 buttons
-                        if (PRESSED(PSP_CTRL_LTRIGGER)) {                       // Don't say we used up the input
-                                _state = kLTriggerDown;
-                                goto END;
-                        }
-                        else if (PRESSED(PSP_CTRL_RTRIGGER)) {          // Don't say we used up the input
-                                _state = kRTriggerDown;
-                                goto END;
-                        }
-
-                        if (DOWN(PSP_4BUTTONS))
-                                usedInput = true;                                               // Make sure these button presses don't get through
-                } else { /* _state == kCornersSelected */
-                        // We care about 4 buttons + triggers (for letter selection)
-                        changed = CHANGED(PSP_4BUTTONS | PSP_CTRL_RTRIGGER | PSP_CTRL_LTRIGGER);
-
-                        if (DOWN(PSP_4BUTTONS | PSP_CTRL_RTRIGGER | PSP_CTRL_LTRIGGER))
-                                usedInput = true;       // Make sure these button presses don't get through
-                }
-
-                if (changed) { //pressing a char select button -- both states
-
-                        int innerChoice;
-
-                        if (UNPRESSED(PSP_CTRL_TRIANGLE)) {
-                                innerChoice = 0;
-                                event.type = Common::EVENT_KEYUP;                       // We give priority to key_up
-                        } else if (UNPRESSED(PSP_CTRL_CIRCLE)) {
-                                innerChoice = 1;
-                                event.type = Common::EVENT_KEYUP;                       // We give priority to key_up
-                        } else if (UNPRESSED(PSP_CTRL_CROSS)) {
-                                innerChoice = 2;
-                                event.type = Common::EVENT_KEYUP;                       // We give priority to key_up
-                        } else if (UNPRESSED(PSP_CTRL_SQUARE)) {
-                                innerChoice = 3;
-                                event.type = Common::EVENT_KEYUP;                       // We give priority to key_up
-                        } else if (UNPRESSED(PSP_CTRL_LTRIGGER) && _state == kCornersSelected) {
-                                innerChoice = 4;
-                                event.type = Common::EVENT_KEYUP;                       // We give priority to key_up
-                        } else if (UNPRESSED(PSP_CTRL_RTRIGGER) && _state == kCornersSelected) {
-                                innerChoice = 5;
-                                event.type = Common::EVENT_KEYUP;                       // We give priority to key_up
-                        } else if (PRESSED(PSP_CTRL_TRIANGLE)) {
-                                innerChoice = 0;
-                                event.type = Common::EVENT_KEYDOWN;
-                        } else if (PRESSED(PSP_CTRL_CIRCLE)) {
-                                innerChoice = 1;
-                                event.type = Common::EVENT_KEYDOWN;
-                        } else if (PRESSED(PSP_CTRL_CROSS)) {
-                                innerChoice = 2;
-                                event.type = Common::EVENT_KEYDOWN;
-                        } else if (PRESSED(PSP_CTRL_SQUARE)) {
-                                innerChoice = 3;
-                                event.type = Common::EVENT_KEYDOWN;
-                        } else if (PRESSED(PSP_CTRL_LTRIGGER) && _state == kCornersSelected) {
-                                innerChoice = 4;
-                                event.type = Common::EVENT_KEYDOWN;                     // We give priority to key_up
-                        } else  /* (UNPRESSED(PSP_CTRL_RTRIGGER)) && _state == kCornersSelected */ {
-                                innerChoice = 5;
-                                event.type = Common::EVENT_KEYDOWN;                     // We give priority to key_up
-                        }
-
-                        #define IS_UPPERCASE(x) ((x) >= (unsigned short)'A' && (x) <= (unsigned short)'Z')
-                        #define TO_LOWER(x)             ((x) += 'a'-'A')
-
-                        //Now grab the value out of the array
-                        short choice = _modeChar[_mode][_oldCursor][innerChoice];
-
-                        event.kbd.ascii = choice <= 255 ? choice : 0;
-
-                        // Handle upper-case which is missing in Common::KeyCode
-                        if (IS_UPPERCASE(choice)) {
-                                event.kbd.keycode = (Common::KeyCode) TO_LOWER(choice);
-                                event.kbd.flags = Common::KBD_SHIFT;
-                        } else
-                                event.kbd.keycode = (Common::KeyCode) choice;
-
-                        haveEvent = (choice != Common::KEYCODE_INVALID) ? true : false; // We have an event/don't if it's invalid
-                        usedInput = true;
-                }
-        }
-
-        // Check for movement of cursor
-        if (_state == kDefault || _state == kCornersSelected) {
-                // Check if a dependent button is down
-                if (_state == kDefault)
-                        keyDown = DOWN(PSP_4BUTTONS);
-                else /* if (_state == kCornersSelected) */
-                        keyDown = DOWN(PSP_4BUTTONS | PSP_CTRL_RTRIGGER | PSP_CTRL_LTRIGGER);
-
-                Cursor cursor = _oldCursor;
-
-                // Find where the cursor is pointing
-                if (keyDown == false) { // Don't allow movement if a nub-dependent key is down
-                        cursor = kCenter;
-                        _state = kDefault;
-
-                        if (DOWN(PSP_DPAD)) {
-                                _state = kCornersSelected;
-                                usedInput = true;       // Make sure the pressed d-pad is used up
-
-                                if (DOWN(PSP_CTRL_UP))
-                                        cursor = kUp;
-                                else if (DOWN(PSP_CTRL_RIGHT))
-                                        cursor = kRight;
-                                else if (DOWN(PSP_CTRL_DOWN))
-                                        cursor = kDown;
-                                else if (DOWN(PSP_CTRL_LEFT))
-                                        cursor = kLeft;
-                        }
-                }
-
-                if (cursor != _oldCursor) { //If we've moved, update dirty and return
-                        _dirty = true;
-                        _oldCursor = cursor;
-                        usedInput = true;               // We 'used up' the input
-                        //goto END;                             // We didn't find an event
-                }
-        }
-
-        // Deal with trigger states
-        if (_state == kRTriggerDown) {
-                usedInput = true;
-
-                if (UNPRESSED(PSP_CTRL_RTRIGGER)) {
-                        _dirty = true;
-
-                        if(_mode > 1)
-                                _mode = 0;
-                        else
-                                _mode = (_mode == 0) ? 1 : 0;
-
-                        usedInput = true;
-                        _state = kDefault;
-
-                        goto END;
-                }
-        } else if (_state == kLTriggerDown) {
-                usedInput = true;
-
-                if (UNPRESSED(PSP_CTRL_LTRIGGER)) {
-                        _dirty = true;
-
-                        if(_mode < 2)
-                                _mode = 2;
-                        else
-                                _mode = (_mode == 2) ? 3 : 2;
-
-                        usedInput = true;
-                        _state = kDefault;
-
-                        goto END;
-                }
-        }
-
-        // Handle start button: enter plus make keyboard invisible
-        if (CHANGED(PSP_CTRL_START)) {
-                event.kbd.ascii = '\n';
-                event.kbd.keycode = Common::KEYCODE_RETURN;
-                event.type = DOWN(PSP_CTRL_START) ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP;
-                usedInput = true;                                       // Don't let start get through
-                haveEvent = true;
-                if (UP(PSP_CTRL_START))
-                        _state = kInvisible;                    // Make us invisible if unpressed
-        }
-
-END:
-        _prevButtons = pad.Buttons;
-        return haveEvent;
+        setDirty();
 }
 
-
 /* move the position the keyboard is currently drawn at */
 void PSPKeyboard::moveTo(const int newX, const int newY) {
-        _moved_x = newX;
-        _moved_y = newY;
+        DEBUG_ENTER_FUNC();
+        
+        _movedX = newX;
+        _movedY = newY;
+        setDirty();
+        
+        DEBUG_EXIT_FUNC();
 }
 
 /* move the position the keyboard is currently drawn at */
 void PSPKeyboard::increaseKeyboardLocationX(int amount) {
-        int newX = _moved_x + amount;
+        DEBUG_ENTER_FUNC();
+        
+        int newX = _movedX + amount;
 
-        if (newX > PSP_SCREEN_WIDTH - 5 || newX < 0 - 140)      // clamp
+        if (newX > PSP_SCREEN_WIDTH - 5 || newX < 0 - 140) {    // clamp
+                DEBUG_EXIT_FUNC();
                 return;
-        _moved_x = newX;
+        }       
+        _movedX = newX;
+        setDirty();
+        
+        DEBUG_EXIT_FUNC();
 }
 
 /* move the position the keyboard is currently drawn at */
 void PSPKeyboard::increaseKeyboardLocationY(int amount) {
-        int newY = _moved_y + amount;
+        DEBUG_ENTER_FUNC();
+        
+        int newY = _movedY + amount;
 
-        if (newY > PSP_SCREEN_HEIGHT - 5 || newY < 0 - 140)     // clamp
+        if (newY > PSP_SCREEN_HEIGHT - 5 || newY < 0 - 140)     { // clamp
+                DEBUG_EXIT_FUNC();
                 return;
-        _moved_y = newY;
+        }
+        _movedY = newY;
+        setDirty();
+        
+        DEBUG_EXIT_FUNC();
 }
 
 /* draw the keyboard at the current position */
 void PSPKeyboard::render() {
-        _dirty = false;
+        DEBUG_ENTER_FUNC();
+
+        unsigned int currentBuffer = _mode<<1;
+        
+        // Draw the background letters
+        // Set renderer to current buffer & palette
+        _renderer.setBuffer(&_buffers[currentBuffer]);
+        _renderer.setPalette(&_palettes[currentBuffer]);
+        _renderer.setOffsetOnScreen(_movedX, _movedY);
+        _renderer.setOffsetInBuffer(0, 0);
+        _renderer.setDrawWholeBuffer();
+        _renderer.render();
+        
+        // Get X and Y coordinates for the orange block
         int x, y;
+        convertCursorToXY(_oldCursor, x, y);
+        
+        const int OrangeBlockSize = 64;
+        const int GrayBlockSize = 43;
+        
+        // Draw the current Highlighted Selector (orange block)
+        _renderer.setBuffer(&_buffers[currentBuffer + 1]);
+        _renderer.setPalette(&_palettes[currentBuffer + 1]);
+        _renderer.setOffsetOnScreen(_movedX + (x * GrayBlockSize), _movedY + (y * GrayBlockSize));
+        _renderer.setOffsetInBuffer(x * OrangeBlockSize, y * OrangeBlockSize);
+        _renderer.setDrawSize(OrangeBlockSize, OrangeBlockSize);
+        _renderer.render();
+        
+        DEBUG_EXIT_FUNC();              
+}
 
-        switch(_oldCursor) {
+inline void PSPKeyboard::convertCursorToXY(CursorDirections cur, int &x, int &y) {
+        switch(cur) {
         case kUp:
                 x = 1;
                 y = 0;
@@ -423 +257 @@
                 y = 1;
                 break;
         }
-
-        // Draw the background letters
-        surface_draw_offset(&_keyTextures[_mode<<1], 0, 0, 0, 0,
-                        _keyTextures[_mode<<1].texture_width,
-                        _keyTextures[_mode<<1].texture_height);
-
-        // Draw the current Highlighted Selector (orange bit)
-        surface_draw_offset(&_keyTextures[(_mode<<1) + 1],
-                        //Offset from the current draw position to render at
-                        x * 43, y * 43,
-                        //internal offset of the image
-                        x * 64, y * 64,
-                        //size to render (always the same)
-                        64, 64);
 }
 
-
-//  Render the given surface at the current screen position offset by screenX, screenY
-//  the surface will be internally offset by offsetX,offsetY. And the size of it to be drawn will be intWidth,intHeight
-void PSPKeyboard::surface_draw_offset(struct gu_surface* surface, int screenX, int screenY, int offsetX, int offsetY, int intWidth, int intHeight) {
-        sceGuAlphaFunc( GU_GREATER, 0, 0xff );
-        sceGuEnable( GU_ALPHA_TEST );
-        sceGuTexFunc(GU_TFX_BLEND,GU_TCC_RGBA);
-        sceGuTexEnvColor(0xFF000000);
-        sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0 );
-        sceGuEnable(GU_BLEND);
-        if (surface->paletteSize == 256) {      // 8-bit
-                sceGuClutMode(GU_PSM_8888, 0, 0xFF, 0);
-                sceGuClutLoad(32, surface->palette); // upload 32*8 entries (256)
-                sceGuTexMode(GU_PSM_T8, 0, 0, 0);   // 8-bit image
-        } else if (surface->paletteSize == 16) {        // 4-bit
-                sceGuClutMode(GU_PSM_8888, 0, 0x0F, 0);
-                sceGuClutLoad(2, surface->palette); // upload 2*8 entries (16)
-                sceGuTexMode(GU_PSM_T4, 0, 0, 0);   // 4-bit image
-        } else {        // 32-bit
-                sceGuTexMode(GU_PSM_8888,0,0,GU_FALSE);
-        }
-        sceGuTexImage(0,surface->surface_width, surface->surface_height,surface->surface_width, surface->texture);
-        sceGuTexFunc(GU_TFX_MODULATE,GU_TCC_RGBA);
-
-        Vertex* c_vertices = (Vertex*)sceGuGetMemory(2 * sizeof(Vertex));
-
-        c_vertices[0].u                 = offsetX;
-        c_vertices[0].v                 = offsetY;
-        c_vertices[0].x                 = _moved_x + screenX;
-        c_vertices[0].y                 = _moved_y + screenY;
-        c_vertices[0].z                 = 0;
-        c_vertices[0].color     = 0xFFFFFFFF;
-
-        c_vertices[1].u                 = offsetX + intWidth;
-        c_vertices[1].v                 = offsetY + intHeight;
-        c_vertices[1].x                 = _moved_x + screenX + intWidth;
-        c_vertices[1].y                 = _moved_y + screenY + intHeight;
-        c_vertices[1].z                 = 0;
-        c_vertices[1].color     = 0xFFFFFFFF;
-
-        sceGuDrawArray(GU_SPRITES,GU_TEXTURE_32BITF|GU_COLOR_8888|GU_VERTEX_32BITF|GU_TRANSFORM_2D,2,0,c_vertices);
-
-        sceGuDisable( GU_BLEND );
-        sceGuDisable( GU_ALPHA_TEST );
-}
-
-/* load all the guibits that make up the OSK */
+/* load the keyboard into memory */
 bool PSPKeyboard::load() {
-        unsigned char *temp_texture = NULL;
-        uint32 *temp_palette = NULL;
-        int a;
+        DEBUG_ENTER_FUNC();
 
-        if (_init)
+        if (_init) {
+                PSP_DEBUG_PRINT("keyboard already loaded into memory\n");
+                DEBUG_EXIT_FUNC();
                 return true;
+        }
 
         // For the shell, we must use a hack
 #ifdef PSP_KB_SHELL
@@ -500 +275 @@
 #else /* normal mode */
         Common::FSNode node(".");                               // Look in current directory
 #endif
-#ifdef PSP_KB_DEBUG
-        fprintf(stderr, "path = %s\n", node.getPath().c_str());
-#endif
+        PSP_DEBUG_PRINT("path[%s]\n", node.getPath().c_str());
 
         Common::Archive *fileArchive = NULL;
         Common::Archive *zipArchive = NULL;
         Common::SeekableReadStream * file = 0;
 
         if (node.getChild("kbd").exists() && node.getChild("kbd").isDirectory()) {
-#ifdef PSP_KB_DEBUG
-                fprintf(stderr, "found directory ./kbd\n");
-#endif
+                PSP_DEBUG_PRINT("found directory ./kbd\n");
                 fileArchive = new Common::FSDirectory(node.getChild("kbd"));
         }
         if (node.getChild("kbd.zip").exists()) {
-#ifdef PSP_KB_DEBUG
-                fprintf(stderr, "found kbd.zip\n");
-#endif
+                PSP_DEBUG_PRINT("found kbd.zip\n");
                 zipArchive  = Common::makeZipArchive(node.getChild("kbd.zip"));
         }
 
-        // Loop through different png images
-        for (a = 0; a < guiStringsSize; a++) {
+        int i;
+        
+        // Loop through all png images
+        for (i = 0; i < guiStringsSize; i++) {
                 uint32 height = 0, width = 0, paletteSize = 0;
 
-#ifdef PSP_KB_DEBUG
-                fprintf(stderr, "load(): Opening %s.\n", _guiStrings[a]);
-#endif
+                PSP_DEBUG_PRINT("Opening %s.\n", _guiStrings[i]);
 
                 // Look for the file in the kbd directory
-                if (fileArchive && fileArchive->hasFile(_guiStrings[a])) {
+                if (fileArchive && fileArchive->hasFile(_guiStrings[i])) {
+                        PSP_DEBUG_PRINT("found it in kbd directory.\n");
 
-#ifdef PSP_KB_DEBUG
-                        fprintf(stderr, "load(): found it in kbd directory.\n");
-#endif
-
-                        file = fileArchive->createReadStreamForMember(_guiStrings[a]);
+                        file = fileArchive->createReadStreamForMember(_guiStrings[i]);
                         if (!file) {
-                                fprintf(stderr, "load(): Can't open kbd/%s for keyboard. No keyboard will load.\n", _guiStrings[a]);
+                                PSP_ERROR("Can't open kbd/%s for keyboard. No keyboard will load.\n", _guiStrings[i]);
                                 goto ERROR;
                         }
                 }
                 // We didn't find it. Look for it in the zip file
-                else if (zipArchive && zipArchive->hasFile(_guiStrings[a])) {
+                else if (zipArchive && zipArchive->hasFile(_guiStrings[i])) {
+                        PSP_DEBUG_PRINT("found it in kbd.zip.\n");
 
-#ifdef PSP_KB_DEBUG
-                        fprintf(stderr, "load(): found it in kbd.zip.\n");
-#endif
-
-                        file = zipArchive->createReadStreamForMember(_guiStrings[a]);
+                        file = zipArchive->createReadStreamForMember(_guiStrings[i]);
                         if (!file) {
-                                fprintf(stderr, "Can't open %s in kbd.zip for keyboard. No keyboard will load.\n", _guiStrings[a]);
+                                PSP_ERROR("Can't open %s in kbd.zip for keyboard. No keyboard will load.\n", _guiStrings[i]);
                                 goto ERROR;
                         }
                 } else {        // Couldn't find the file
-                        fprintf(stderr, "load(): Can't find %s for keyboard. No keyboard will load.\n", _guiStrings[a]);
+                        PSP_ERROR("Can't find %s for keyboard. No keyboard will load.\n", _guiStrings[i]);
                         goto ERROR;
                 }
 
-                if (get_png_image_size(file, &width, &height, &paletteSize) == 0) { // Check image size and palette size
+                if (getPngImageSize(file, &width, &height, &paletteSize) == 0) { // Check image size and palette size
                         // Allocate memory for image
-#ifdef PSP_KB_DEBUG
-                        fprintf(stderr, "load(): width=%d, height=%d, paletteSize=%d\n", width, height, paletteSize);
-#endif
-
+                        PSP_DEBUG_PRINT("width[%d], height[%d], paletteSize[%d]\n", width, height, paletteSize);
+                        _buffers[i].setSize(width, height, Buffer::kSizeByTextureSize);
+                        
                         if (paletteSize) {      // 8 or 4-bit image
-                                uint32 textureSize = 0;
-
                                 if (paletteSize <= 16) { // 4 bit
-                                        paletteSize = 16;
-                                        textureSize = (width * height)>>1;
+                                        _buffers[i].setPixelFormat(PSPPixelFormat::Type_Palette_4bit);
+                                        _palettes[i].setPixelFormats(PSPPixelFormat::Type_4444, PSPPixelFormat::Type_Palette_4bit);
+                                        paletteSize = 16;                                       
                                 } else if (paletteSize <= 256){                 // 8-bit image
                                         paletteSize = 256;
-                                        textureSize = width * height;
+                                        _buffers[i].setPixelFormat(PSPPixelFormat::Type_Palette_8bit);
+                                        _palettes[i].setPixelFormats(PSPPixelFormat::Type_4444, PSPPixelFormat::Type_Palette_8bit);
                                 } else {
-                                        fprintf(stderr, "Error: palette of %d too big!\n", paletteSize);
+                                        PSP_ERROR("palette of %d too big!\n", paletteSize);
                                         goto ERROR;
                                 }
-#ifdef PSP_KB_DEBUG
-                                fprintf(stderr, "load(): allocating %d bytes for texture and %d for palette\n", textureSize, paletteSize*4);
-#endif
-                                temp_texture = (u8 *)malloc(textureSize);
-                                temp_palette = (uint32 *)memalign(16, paletteSize<<2);
-                                memset(temp_palette, 0, paletteSize<<2);        // Set to 0 since we might only fill some of it
+                                
                         } else {                                // 32-bit image
-                                temp_texture = (unsigned char *)malloc((width * height)<<2);
+                                _buffers[i].setPixelFormat(PSPPixelFormat::Type_8888);
                         }
+                        
+                        _buffers[i].allocate();
+                        _palettes[i].allocate();
 
                         // Try to load the image
                         file->seek(0);  // Go back to start
 
-                        if (load_png_image(file, temp_texture, temp_palette) != 0)
+                        if (loadPngImage(file, _buffers[i], _palettes[i]) != 0)
                                 goto ERROR;
                         else {  // Success
-#ifdef PSP_KB_DEBUG
-                                fprintf(stderr, "Managed to load the image.\n");
-#endif
-                                // we need to store the texture in an image of width and heights of 2^n sizes
-                                _keyTextures[a].texture_width   = width;                                                // original size
-                                _keyTextures[a].texture_height  = height;
-                                _keyTextures[a].surface_width   = convert_pow2(width);          // converted size
-                                _keyTextures[a].surface_height  = convert_pow2(height);
-                                _keyTextures[a].palette                 = temp_palette;
-                                _keyTextures[a].paletteSize     = paletteSize;
+                                PSP_DEBUG_PRINT("Managed to load the image\n");
 
-                                uint32 size;
-
-                                if (paletteSize == 16)                  // 4 bit
-                                        size = (_keyTextures[a].surface_width * _keyTextures[a].surface_height)>>1;
-                                else if (paletteSize == 256)    // 8-bit
-                                        size = _keyTextures[a].surface_width * _keyTextures[a].surface_height;
-                                else                                                    // 32 bit
-                                        size = (_keyTextures[a].surface_width * _keyTextures[a].surface_height)<<2;
-
-#ifdef PSP_KB_DEBUG
-                                fprintf(stderr, "load(): perm texture width=%d, height=%d, size=%d\n", _keyTextures[a].surface_width, _keyTextures[a].surface_height, size);
-#endif
-                                _keyTextures[a].texture = (unsigned char *)memalign(16, size);  // Allocate memory
-
-                                block_copy(&_keyTextures[a], temp_texture);                     // Copy temp texture to permanent texture
-
                                 if (paletteSize == 16)          // 4-bit
-                                        flipNibbles(&_keyTextures[a]);
+                                        _buffers[i].flipNibbles();
 
-                                free(temp_texture);
-
                                 delete file;
                         }
                 }
-                else
+                else {
+                        PSP_ERROR("couldn't obtain PNG image size\n");
                         goto ERROR;
+                }
         } /* for loop */
+        
         _init = true;
 
         delete fileArchive;
         delete zipArchive;
 
+        DEBUG_EXIT_FUNC();
         return true;
 
 ERROR:
 
-        // Error .. Couldn't get png info from one of the needed files
-        free(temp_texture);
         delete file;
         delete fileArchive;
         delete zipArchive;
 
-        for (int b = 0; b < a; b++) {
-                free(_keyTextures[b].texture);
-                free(_keyTextures[b].palette);
-                _keyTextures[b].texture = NULL;
+        for (int j = 0; j < i; j++) {
+                _buffers[j].deallocate();
+                _palettes[j].deallocate();
         }
         _init = false;
+        
+        DEBUG_EXIT_FUNC();
         return false;
 }
 
-// Copy texture from regular size image to power of 2 size image
-//
-void PSPKeyboard::block_copy(gu_surface* surface, u8 *texture) {
-        u32 stride = 0, width = 0;
-
-        switch(surface->paletteSize) {
-        case 16:        // 4-bit
-                width = surface->texture_width >> 1;
-                stride = (surface->surface_width - surface->texture_width)>>1;
-                break;
-        case 256:       // 8-bit
-                width = surface->texture_width;
-                stride = surface->surface_width - surface->texture_width;
-                break;
-        case 0:         // 32-bit
-                width = surface->texture_width << 2;
-                stride = (surface->surface_width - surface->texture_width)<<2;
-                break;
-        default:
-                fprintf(stderr, "Error in block_copy: bad value in paletteSize = %d\n", surface->paletteSize);
-                return;
-        }
-
-        u8 *src  = texture;
-        u8 *dest = surface->texture;
-
-        for (unsigned int y = 0; y < surface->texture_height; y++) {
-                memcpy(dest, src, width);
-                dest += width;
-                src += width;
-
-                // skip at the end of each line
-                if (stride > 0) {
-                        dest += stride;
-                }
-        }
-}
-
-// Convert 4 bit images to match weird PSP format
-//
-void PSPKeyboard::flipNibbles(gu_surface* surface) {
-        u32 *dest = (u32 *)surface->texture;
-
-        for (u32 y = 0; y < surface->texture_height; y++) {
-                for (u32 x = 0; x < (surface->surface_width >> 3); x++) {
-                        u32 val = *dest;
-                        *dest++ = ((val >> 4) & 0x0F0F0F0F) | ((val << 4) & 0xF0F0F0F0);
-                }
-        }
-
-}
-
-
 static void user_warning_fn(png_structp png_ptr, png_const_charp warning_msg) {
         // ignore PNG warnings
 }
 
 /* Get the width and height of a png image */
-int PSPKeyboard::get_png_image_size(Common::SeekableReadStream *file, uint32 *png_width, uint32 *png_height, u32 *paletteSize) {
+int PSPKeyboard::getPngImageSize(Common::SeekableReadStream *file, uint32 *png_width, uint32 *png_height, u32 *paletteSize) {
+        DEBUG_ENTER_FUNC();
+        
         png_structp png_ptr;
         png_infop info_ptr;
         unsigned int sig_read = 0;
@@ -723 +408 @@
 
         png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
         if (png_ptr == NULL) {
+                DEBUG_EXIT_FUNC();
                 return -1;
         }
         png_set_error_fn(png_ptr, (png_voidp) NULL, (png_error_ptr) NULL, user_warning_fn);
         info_ptr = png_create_info_struct(png_ptr);
         if (info_ptr == NULL) {
                 png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
+                DEBUG_EXIT_FUNC();
                 return -1;
         }
         // Set the png lib to use our read function
@@ -746 +433 @@
 
         *png_width = width;
         *png_height = height;
+        
+        DEBUG_EXIT_FUNC();
         return 0;
 }
 
 // Load a texture from a png image
 //
-int PSPKeyboard::load_png_image(Common::SeekableReadStream *file, unsigned char *ImageBuffer, uint32 *palette) {
+int PSPKeyboard::loadPngImage(Common::SeekableReadStream *file, Buffer &buffer, Palette &palette) {
+        DEBUG_ENTER_FUNC();
+        
         png_structp png_ptr;
         png_infop info_ptr;
         unsigned int sig_read = 0;
         png_uint_32 width, height;
         int bit_depth, color_type, interlace_type;
-        size_t x, y;
+        size_t y;
 
         png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
         if (png_ptr == NULL) {
-                fprintf(stderr, "load_png_image(): Error: couldn't create read struct to load keyboard.\n");
+                PSP_ERROR("Couldn't create read struct to load keyboard\n");
+                DEBUG_EXIT_FUNC();
                 return -1;
         }
         // Use dummy error function
@@ -769 +461 @@
 
         info_ptr = png_create_info_struct(png_ptr);
         if (info_ptr == NULL) {
+                PSP_ERROR("Couldn't create info struct to load keyboard\n");
                 png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
+                DEBUG_EXIT_FUNC();
                 return -1;
         }
 
-        // Set the png lib to use our read function
+        // Set the png lib to use our customized read function
         png_set_read_fn(png_ptr, (void *)file, pngReadStreamRead);
 
         png_set_sig_bytes(png_ptr, sig_read);
@@ -784 +478 @@
         png_set_strip_16(png_ptr);
 
         if (color_type == PNG_COLOR_TYPE_PALETTE) {
-                // We copy the palette
-                uint32 *dstPal = palette;
+                // Copy the palette
                 png_colorp srcPal = info_ptr->palette;
                 for(int i=0; i < info_ptr->num_palette; i++) {
                         unsigned char alphaVal = (i < info_ptr->num_trans) ? info_ptr->trans[i] : 0xFF; // Load alpha if it's there
-                        *dstPal++ = GU_ARGB(alphaVal, srcPal->red, srcPal->green, srcPal->blue);
+                        palette.setSingleColorRGBA(i, srcPal->red, srcPal->green, srcPal->blue, alphaVal);
                         srcPal++;
                 }
-
-                unsigned char *line = (unsigned char*) malloc(info_ptr->rowbytes);
-                if (!line) {
-                        png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
-                        return -1;
-                }
-
-                for (y = 0; y < height; y++) {
-                        png_read_row(png_ptr, line, png_bytep_NULL);
-                        memcpy(&ImageBuffer[y * info_ptr->rowbytes], line, info_ptr->rowbytes);
-                }
-
-                free(line);
         } else {        // Not a palettized image
+                // Round up grayscale images
                 if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) png_set_gray_1_2_4_to_8(png_ptr);
                 // Convert trans channel to alpha for 32 bits
                 if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr);
+                // Filler for alpha?
                 png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
+        }       
 
-                u32* line = (u32*) malloc(width<<2);
-                if (!line) {
-                        png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
-                        return -1;
-                }
+        unsigned char *line = (unsigned char*) malloc(info_ptr->rowbytes);
+        if (!line) {
+                png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
+                PSP_ERROR("Couldn't allocate line\n");
+                DEBUG_EXIT_FUNC();
+                return -1;
+        }
 
-                u32* Image = (u32 *)ImageBuffer;
-                for (y = 0; y < height; y++) {
-                        png_read_row(png_ptr, (u8*) line, png_bytep_NULL);
-                        for (x = 0; x < width; x++) {
-                                Image[y*width + x] = line[x];
-                        }
-                }
-
-                free(line);
+        for (y = 0; y < height; y++) {
+                png_read_row(png_ptr, line, png_bytep_NULL);
+                buffer.copyFromRect(line, info_ptr->rowbytes, 0, y, width, 1);  // Copy into buffer
+                //memcpy(buffer.getPixels()[y * buffer.getWidthInBytes()], line, info_ptr->rowbytes);
         }
 
+        free(line);
+        
         png_read_end(png_ptr, info_ptr);
         png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
 
+        DEBUG_EXIT_FUNC();
         return 0;
 }
 
-// Function to get the lowest power of 2 higher than our image size
-//
-uint32 PSPKeyboard::convert_pow2(uint32 size) {
-        uint32 pow_counter = 0;
+// Defines for working with PSP buttons
+#define CHANGED(x)       (_buttonsChanged & (x))
+#define PRESSED(x)   ((_buttonsChanged & (x)) && (pad.Buttons & (x)))
+#define UNPRESSED(x) ((_buttonsChanged & (x)) && !(pad.Buttons & (x)))
+#define DOWN(x)          (pad.Buttons & (x))
+#define UP(x)            (!(pad.Buttons & (x)))
+#define PSP_DPAD         (PSP_CTRL_DOWN|PSP_CTRL_UP|PSP_CTRL_LEFT|PSP_CTRL_RIGHT)
+#define PSP_4BUTTONS (PSP_CTRL_CROSS | PSP_CTRL_CIRCLE | PSP_CTRL_TRIANGLE | PSP_CTRL_SQUARE)
 
-        for (; pow_counter < 32; pow_counter++) {
-                // Find the first value which is higher
-                if ((size >> pow_counter) == 0) {
-                        // take already good values into account
-                        if (((uint32) 1 << pow_counter) != size)
-                                return ((uint32)1 << pow_counter);
-                        else
-                                return ((uint32)1 << (pow_counter-1));
+/*
+ *  Attempts to read a character from the controller
+ *  Uses the state machine.
+ *  returns whether we have an event
+ */
+bool PSPKeyboard::processInput(Common::Event &event, SceCtrlData &pad) {
+        DEBUG_ENTER_FUNC();
+        
+        bool haveEvent = false;         // Whether we have an event for the event manager to process
+        event.kbd.flags = 0;
+        
+        _buttonsChanged = _prevButtons ^ pad.Buttons;
+
+        if (!_init)                                     // In case we never had init
+                return false;
+        if (_state == kInvisible)       // Return if we're invisible
+                return false;   
+        if (_state != kMove && PRESSED(PSP_CTRL_SELECT)) {
+                _lastState = _state;
+                _state = kMove;                 // Check for move or visible state
+        }
+        else if (CHANGED(PSP_CTRL_START)) {             // Handle start button: enter, make KB invisible
+                event.kbd.ascii = '\r';
+                event.kbd.keycode = Common::KEYCODE_RETURN;
+                event.type = DOWN(PSP_CTRL_START) ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP;
+                haveEvent = true;
+                _dirty = true;
+                if (UP(PSP_CTRL_START))
+                        _state = kInvisible;                    // Make us invisible if unpressed
+        }       
+        // Check for being in state of moving the keyboard onscreen or pressing select
+        else if (_state == kMove)
+                handleMoveState(pad);
+        else if (_state == kDefault)
+                haveEvent = handleDefaultState(event, pad);
+        else if (_state == kCornersSelected)
+                haveEvent = handleCornersSelectedState(event, pad);
+        else if (_state == kRTriggerDown)
+                handleRTriggerDownState(pad);   // Deal with trigger states
+        else if (_state == kLTriggerDown)
+                handleLTriggerDownState(pad);   // Deal with trigger states
+
+        _prevButtons = pad.Buttons;
+        
+        DEBUG_EXIT_FUNC();
+        return haveEvent;
+}
+
+void PSPKeyboard::handleMoveState(SceCtrlData &pad) {
+        DEBUG_ENTER_FUNC();
+        if (UP(PSP_CTRL_SELECT)) {
+                // Toggle between visible and invisible
+                _state = (_lastState == kInvisible) ? kDefault : kInvisible;            
+                _dirty = true;
+
+                if (_moved) {                                   // We moved the keyboard. Keep the keyboard onscreen anyway
+                        _state = kDefault;
+                        _moved = false;                         // reset moved flag
                 }
+        } else if (DOWN(PSP_DPAD)) {            // How we move the KB onscreen
+                _moved = true;
+                _dirty = true;
+
+                if (DOWN(PSP_CTRL_DOWN))
+                        increaseKeyboardLocationY(5);
+                else if (DOWN(PSP_CTRL_UP))
+                        increaseKeyboardLocationY(-5);
+                else if (DOWN(PSP_CTRL_LEFT))
+                        increaseKeyboardLocationX(-5);
+                else  /* DOWN(PSP_CTRL_RIGHT) */
+                        increaseKeyboardLocationX(5);
         }
-        return 0;
+        DEBUG_EXIT_FUNC();      
 }
 
+bool PSPKeyboard::handleDefaultState(Common::Event &event, SceCtrlData &pad) {
+        DEBUG_ENTER_FUNC();
+        bool haveEvent = false;
+        
+        if (PRESSED(PSP_CTRL_LTRIGGER))                         // Don't say we used up the input
+                _state = kLTriggerDown;         
+        else if (PRESSED(PSP_CTRL_RTRIGGER))    // Don't say we used up the input
+                _state = kRTriggerDown;         
+        else if (CHANGED(PSP_4BUTTONS))                 // We only care about the 4 buttons
+                haveEvent = getInputChoice(event, pad);
+        else if (!DOWN(PSP_4BUTTONS))                           // Must be up to move cursor
+                getCursorMovement(pad);
+        
+        DEBUG_EXIT_FUNC();
+        return haveEvent;
+}
+
+bool PSPKeyboard::handleCornersSelectedState(Common::Event &event, SceCtrlData &pad) {
+        DEBUG_ENTER_FUNC();
+        // We care about 4 buttons + triggers (for letter selection)
+        bool haveEvent = false;
+        
+        if (CHANGED(PSP_4BUTTONS | PSP_CTRL_RTRIGGER | PSP_CTRL_LTRIGGER))
+                haveEvent = getInputChoice(event, pad);
+        if (!DOWN(PSP_4BUTTONS | PSP_CTRL_RTRIGGER | PSP_CTRL_LTRIGGER)) // Must be up to move cursor
+                getCursorMovement(pad)
+        
+        DEBUG_EXIT_FUNC();      
+        return haveEvent;
+}
+
+bool PSPKeyboard::getInputChoice(Common::Event &event, SceCtrlData &pad) {
+        DEBUG_ENTER_FUNC();
+        int innerChoice;
+        bool haveEvent = false;
+
+        if (UNPRESSED(PSP_CTRL_TRIANGLE)) {
+                innerChoice = 0;
+                event.type = Common::EVENT_KEYUP;                       // We give priority to key_up
+        } else if (UNPRESSED(PSP_CTRL_CIRCLE)) {
+                innerChoice = 1;
+                event.type = Common::EVENT_KEYUP;                       // We give priority to key_up
+        } else if (UNPRESSED(PSP_CTRL_CROSS)) {
+                innerChoice = 2;
+                event.type = Common::EVENT_KEYUP;                       // We give priority to key_up
+        } else if (UNPRESSED(PSP_CTRL_SQUARE)) {
+                innerChoice = 3;
+                event.type = Common::EVENT_KEYUP;                       // We give priority to key_up
+        } else if (UNPRESSED(PSP_CTRL_LTRIGGER) && _state == kCornersSelected) {
+                innerChoice = 4;
+                event.type = Common::EVENT_KEYUP;                       // We give priority to key_up
+        } else if (UNPRESSED(PSP_CTRL_RTRIGGER) && _state == kCornersSelected) {
+                innerChoice = 5;
+                event.type = Common::EVENT_KEYUP;                       // We give priority to key_up
+        } else if (PRESSED(PSP_CTRL_TRIANGLE)) {
+                innerChoice = 0;
+                event.type = Common::EVENT_KEYDOWN;
+        } else if (PRESSED(PSP_CTRL_CIRCLE)) {
+                innerChoice = 1;
+                event.type = Common::EVENT_KEYDOWN;
+        } else if (PRESSED(PSP_CTRL_CROSS)) {
+                innerChoice = 2;
+                event.type = Common::EVENT_KEYDOWN;
+        } else if (PRESSED(PSP_CTRL_SQUARE)) {
+                innerChoice = 3;
+                event.type = Common::EVENT_KEYDOWN;
+        } else if (PRESSED(PSP_CTRL_LTRIGGER) && _state == kCornersSelected) {
+                innerChoice = 4;
+                event.type = Common::EVENT_KEYDOWN;                     // We give priority to key_up
+        } else  /* (PRESSED(PSP_CTRL_RTRIGGER)) && _state == kCornersSelected */ {
+                innerChoice = 5;
+                event.type = Common::EVENT_KEYDOWN;                     // We give priority to key_up
+        }
+
+        #define IS_UPPERCASE(x) ((x) >= (unsigned short)'A' && (x) <= (unsigned short)'Z')
+        #define TO_LOWER(x)             ((x) += 'a'-'A')
+
+        //Now grab the value out of the array
+        short choice = _modeChar[_mode][_oldCursor][innerChoice];
+
+        event.kbd.ascii = choice <= 255 ? choice : 0;
+
+        // Handle upper-case which is missing in Common::KeyCode
+        if (IS_UPPERCASE(choice)) {
+                event.kbd.keycode = (Common::KeyCode) TO_LOWER(choice);
+                event.kbd.flags = Common::KBD_SHIFT;
+        } else
+                event.kbd.keycode = (Common::KeyCode) choice;
+
+        haveEvent = (choice != Common::KEYCODE_INVALID) ? true : false; // We have an event/don't if it's invalid
+
+        DEBUG_EXIT_FUNC();
+        return haveEvent;
+}
+
+void PSPKeyboard::getCursorMovement(SceCtrlData &pad) {
+        DEBUG_ENTER_FUNC();
+        CursorDirections cursor;
+        
+        // Find where the cursor is pointing
+        cursor = kCenter;
+        _state = kDefault;
+
+        if (DOWN(PSP_DPAD)) {
+                _state = kCornersSelected;                      
+
+                if (DOWN(PSP_CTRL_UP))
+                        cursor = kUp;
+                else if (DOWN(PSP_CTRL_RIGHT))
+                        cursor = kRight;
+                else if (DOWN(PSP_CTRL_DOWN))
+                        cursor = kDown;
+                else if (DOWN(PSP_CTRL_LEFT))
+                        cursor = kLeft;
+        }
+        
+        if (cursor != _oldCursor) { //If we've moved, update dirty and return
+                _dirty = true;
+                _oldCursor = cursor;
+        }
+        DEBUG_EXIT_FUNC();
+}
+
+void PSPKeyboard::handleLTriggerDownState(SceCtrlData &pad) {
+        DEBUG_ENTER_FUNC();
+        if (UNPRESSED(PSP_CTRL_LTRIGGER)) {
+                _dirty = true;
+
+                if(_mode < 2)
+                        _mode = 2;
+                else
+                        _mode = (_mode == 2) ? 3 : 2;
+
+                _state = kDefault;
+        }
+        DEBUG_EXIT_FUNC();
+}
+
+void PSPKeyboard::handleRTriggerDownState(SceCtrlData &pad) {
+        DEBUG_ENTER_FUNC();
+        if (UNPRESSED(PSP_CTRL_RTRIGGER)) {
+                _dirty = true;
+
+                if(_mode > 1)
+                        _mode = 0;
+                else
+                        _mode = (_mode == 0) ? 1 : 0;
+
+                _state = kDefault;
+        }
+        DEBUG_EXIT_FUNC();
+}

backends/platform/psp/osys_psp.h

@@ -32 +32 @@
 #include "sound/mixer_intern.h"
 #include "backends/base-backend.h"
 #include "backends/fs/psp/psp-fs-factory.h"
+#include "backends/platform/psp/display_client.h"
+#include "backends/platform/psp/default_display_client.h"
+#include "backends/platform/psp/cursor.h"
 #include "backends/platform/psp/pspkeyboard.h"
+#include "backends/platform/psp/display_manager.h"
+#include "backends/platform/psp/input.h"
 
 #include <SDL.h>
 
-#include <pspctrl.h>
-
-enum GraphicModeID {
-        CENTERED_320X200,
-        CENTERED_435X272,
-        STRETCHED_480X272,
-        CENTERED_362X272
-};
-
 class OSystem_PSP : public BaseBackend {
-public:
-        static const OSystem::GraphicsMode s_supportedGraphicsModes[];
-        static OSystem *instance();
-
-protected:
-        struct Vertex {
-                float u,v;
-                float x,y,z;
-        };
-
-        uint16  _screenWidth;
-        uint16  _screenHeight;
-        uint16  _overlayWidth;
-        uint16  _overlayHeight;
-        byte    *_offscreen;
-        OverlayColor  *_overlayBuffer;
-        uint16  _palette[256];
-        bool    _overlayVisible;
-        uint32  _shakePos;
-        uint32  _lastScreenUpdate;
-
-        Graphics::Surface _framebuffer;
-
-        bool    _mouseVisible;
-        int     _mouseX, _mouseY;
-        int _dpadX, _dpadY;
-        int     _mouseWidth, _mouseHeight;
-        int     _mouseHotspotX, _mouseHotspotY;
-        byte    _mouseKeyColour;
-        byte    *_mouseBuf;
-        bool    _cursorPaletteDisabled;
-
-        int _graphicMode;
-        unsigned short* _clut;
-        PSPKeyboard *_keyboard;
-
-        uint32  _prevButtons;
-        uint32  _lastPadCheck;
-        uint32  _padAccel;
-
-        SceCtrlData pad;
-
+private:
+        
         Common::SaveFileManager *_savefile;
         Audio::MixerImpl *_mixer;
         Common::TimerManager *_timer;
 
-        Common::KeyCode getDpadEvent(int x, int y);
+        // All needed sub-members
+        Screen _screen;
+        Overlay _overlay;
+        Cursor _cursor;
+        DisplayManager _displayManager;
+        PSPKeyboard _keyboard;
+        InputHandler _inputHandler;
 
+        void initSDL();
+
 public:
-        OSystem_PSP();
-        virtual ~OSystem_PSP();
+        OSystem_PSP() : _savefile(0), _mixer(0), _timer(0) {}
+        ~OSystem_PSP();
 
-        virtual void initBackend();
-
-        virtual bool hasFeature(Feature f);
-        virtual void setFeatureState(Feature f, bool enable);
-        virtual bool getFeatureState(Feature f);
-
-        virtual const GraphicsMode *getSupportedGraphicsModes() const;
-        virtual int getDefaultGraphicsMode() const;
-        virtual bool setGraphicsMode(int mode);
+        static OSystem *instance();
+        
+        void initBackend();
+        
+        // Feature related
+        bool hasFeature(Feature f);
+        void setFeatureState(Feature f, bool enable);
+        bool getFeatureState(Feature f);
+        
+        // Graphics related
+        const GraphicsMode *getSupportedGraphicsModes() const;
+        int getDefaultGraphicsMode() const;
+        bool setGraphicsMode(int mode);
         bool setGraphicsMode(const char *name);
-        virtual int getGraphicsMode() const;
+        int getGraphicsMode() const;
+#ifdef USE_RGB_COLOR
+        virtual Graphics::PixelFormat getScreenFormat() const;
+        virtual Common::List<Graphics::PixelFormat> getSupportedFormats();
+#endif
+        
+        // Screen size
+        void initSize(uint width, uint height, const Graphics::PixelFormat *format);
+        int16 getWidth();
+        int16 getHeight();
+        
+        // Palette related
+        void setPalette(const byte *colors, uint start, uint num);
+        void grabPalette(byte *colors, uint start, uint num);
+        void setCursorPalette(const byte *colors, uint start, uint num);
+        void disableCursorPalette(bool disable);
+        
+        // Screen related
+        void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h);
+        Graphics::Surface *lockScreen();
+        void unlockScreen();
+        void updateScreen();
+        void setShakePos(int shakeOffset);
+        
+        // Overlay related
+        void showOverlay();
+        void hideOverlay();
+        void clearOverlay();
+        void grabOverlay(OverlayColor *buf, int pitch);
+        void copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h);
+        int16 getOverlayHeight();
+        int16 getOverlayWidth();
+        Graphics::PixelFormat getOverlayFormat() const { return Graphics::createPixelFormat<4444>(); }
+        
+        // Mouse related
+        bool showMouse(bool visible);
+        void warpMouse(int x, int y);
+        void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format);
 
-        virtual void initSize(uint width, uint height, const Graphics::PixelFormat *format);
-        virtual int16 getWidth();
-        virtual int16 getHeight();
+        // Events and input
+        bool pollEvent(Common::Event &event);
+        bool processInput(Common::Event &event);
 
-        virtual void setPalette(const byte *colors, uint start, uint num);
-        virtual void grabPalette(byte *colors, uint start, uint num);
-        virtual void setCursorPalette(const byte *colors, uint start, uint num);
-        virtual void disableCursorPalette(bool disable);
-        virtual void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h);
-        virtual Graphics::Surface *lockScreen();
-        virtual void unlockScreen();
-        virtual void updateScreen();
-        virtual void setShakePos(int shakeOffset);
+        // Time
+        uint32 getMillis();
+        void delayMillis(uint msecs);
 
-        virtual void showOverlay();
-        virtual void hideOverlay();
-        virtual void clearOverlay();
-        virtual void grabOverlay(OverlayColor *buf, int pitch);
-        virtual void copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h);
-        virtual int16 getOverlayHeight();
-        virtual int16 getOverlayWidth();
-        virtual Graphics::PixelFormat getOverlayFormat() const { return Graphics::createPixelFormat<4444>(); }
-
-        virtual bool showMouse(bool visible);
-        virtual void warpMouse(int x, int y);
-        virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format);
-
-        virtual bool pollEvent(Common::Event &event);
-        virtual bool processInput(Common::Event &event);
-
-        virtual uint32 getMillis();
-        virtual void delayMillis(uint msecs);
-
+        // Timer
         typedef int (*TimerProc)(int interval);
-        virtual void setTimerCallback(TimerProc callback, int interval);
+        void setTimerCallback(TimerProc callback, int interval);
+        Common::TimerManager *getTimerManager() { return _timer; }
 
-        virtual MutexRef createMutex(void);
-        virtual void lockMutex(MutexRef mutex);
-        virtual void unlockMutex(MutexRef mutex);
-        virtual void deleteMutex(MutexRef mutex);
+        // Mutex
+        MutexRef createMutex(void);
+        void lockMutex(MutexRef mutex);
+        void unlockMutex(MutexRef mutex);
+        void deleteMutex(MutexRef mutex);
 
+        // Sound
         static void mixCallback(void *sys, byte *samples, int len);
-        virtual void setupMixer(void);
-
-        Common::SaveFileManager *getSavefileManager() { return _savefile; }
+        void setupMixer(void);
         Audio::Mixer *getMixer() { return _mixer; }
-        Common::TimerManager *getTimerManager() { return _timer; }
+        
+        // Misc
+        Common::SaveFileManager *getSavefileManager() { return _savefile; }
         FilesystemFactory *getFilesystemFactory() { return &PSPFilesystemFactory::instance(); }
         void getTimeAndDate(TimeDate &t) const;
 
-        virtual void quit();
+        void quit();
 
-        virtual Common::SeekableReadStream *createConfigReadStream();
-        virtual Common::WriteStream *createConfigWriteStream();
+        Common::SeekableReadStream *createConfigReadStream();
+        Common::WriteStream *createConfigWriteStream();
+
 };
 
-
 #endif /* OSYS_PSP_H */

backends/platform/psp/powerman.cpp

@@ -23 +23 @@
  *
  */
 
+//#define __PSP_DEBUG_FUNCS__   /* can put this locally too */
+//#define __PSP_DEBUG_PRINT__
+#include "backends/platform/psp/trace.h"
+ 
 #include <psppower.h>
 #include <pspthreadman.h>
 
-#include "./powerman.h"
-#include "./trace.h"
+#include "backends/platform/psp/powerman.h"
 #include "engine.h"
 
 DECLARE_SINGLETON(PowerManager)
 
-#ifdef __PSP_DEBUG_SUSPEND__
-void PowerManager::debugPM() {
-        PSPDebugTrace("PM status is %d. Listcount is %d. CriticalCount is %d. ThreadId is %x. Error = %d\n", _PMStatus, _listCounter,
-                _criticalCounter, sceKernelGetThreadId(), _error);
+// Function to debug the Power Manager (we have no output to screen)
+inline void PowerManager::debugPM() {
+        PSP_DEBUG_PRINT("PM status[%d]. Listcount[%d]. CriticalCount[%d]. ThreadId[%x]. Error[%d]\n", 
+                                        _PMStatus, _listCounter, _criticalCounter, sceKernelGetThreadId(), _error);
 }
-#else
-        #define debugPM()
-        #define PMStatusSet(x)
-#endif /* __PSP_DEBUG_SUSPEND__ */
 
 
  /*******************************************
@@ -49 +48 @@
 *
 ********************************************/
 PowerManager::PowerManager() {
-
+        DEBUG_ENTER_FUNC();
+        
         _flagMutex = NULL;                                      /* Init mutex handle */
         _listMutex = NULL;                                      /* Init mutex handle */
         _condSuspendable = NULL;                        /* Init condition variable */
@@ -57 +57 @@
 
         _condSuspendable = SDL_CreateCond();
         if (_condSuspendable <= 0) {
-                PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create condSuspendable\n");
+                PSP_ERROR("Couldn't create Suspendable condition variable\n");
         }
 
         _condPM = SDL_CreateCond();
         if (_condPM <= 0) {
-                PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create condPM\n");
+                PSP_ERROR("Couldn't create PM condition variable\n");
         }
 
         _flagMutex = SDL_CreateMutex();
         if (_flagMutex <= 0) {
-                PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create flagMutex\n");
+                PSP_ERROR("Couldn't create flag Mutex\n");
         }
 
         _listMutex = SDL_CreateMutex();
         if (_listMutex <= 0) {
-                PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create listMutex\n");
+                PSP_ERROR("Couldn't create list Mutex\n");
         }
 
         _suspendFlag = false;
-        _criticalCounter = 0;
-        _pauseFlag = 0; _pauseFlagOld = 0; _pauseClientState = 0;
-
-#ifdef __PSP_DEBUG_SUSPEND__
+        _criticalCounter = 0;   // How many are in the critical section
+        _pauseFlag = 0;
+        _pauseFlagOld = 0; 
+        _pauseClientState = 0;
         _listCounter = 0;
         PMStatusSet(kInitDone);
         _error = 0;
-#endif
+
+        DEBUG_EXIT_FUNC();
  }
 
 /*******************************************
@@ -92 +93 @@
 *
 ********************************************/
 int PowerManager::registerSuspend(Suspendable *item) {
+        DEBUG_ENTER_FUNC();
         // Register in list
-        PSPDebugSuspend("In registerSuspend\n");
         debugPM();
 
         if (SDL_mutexP(_listMutex) != 0) {
-                PSPDebugTrace("PowerManager::registerSuspend(): Couldn't lock _listMutex %d\n", _listMutex);
+                PSP_ERROR("Couldn't lock _listMutex[%p]\n", _listMutex);
         }
 
         _suspendList.push_front(item);
-#ifdef __PSP_DEBUG_SUSPEND__
         _listCounter++;
-#endif
 
         if (SDL_mutexV(_listMutex) != 0) {
-                PSPDebugTrace("PowerManager::registerSuspend(): Couldn't unlock _listMutex %d\n", _listMutex);
+                PSP_ERROR("Couldn't unlock _listMutex[%p]\n", _listMutex);
         }
-
-        PSPDebugSuspend("Out of registerSuspend\n");
+        
         debugPM();
 
+        DEBUG_EXIT_FUNC();
         return 0;
 }
 
@@ -121 +120 @@
 *
 ********************************************/
 int PowerManager::unregisterSuspend(Suspendable *item) {
-
-        PSPDebugSuspend("In unregisterSuspend\n");
+        DEBUG_ENTER_FUNC();
         debugPM();
 
          // Unregister from stream list
         if (SDL_mutexP(_listMutex) != 0) {
-                PSPDebugTrace("PowerManager::unregisterSuspend(): Couldn't unlock _listMutex %d\n", _listMutex);
+                PSP_ERROR("Couldn't unlock _listMutex[%p]\n", _listMutex);
         }
 
         _suspendList.remove(item);
-#ifdef __PSP_DEBUG_SUSPEND__
         _listCounter--;
-#endif
 
         if (SDL_mutexV(_listMutex) != 0) {
-                PSPDebugTrace("PowerManager::unregisterSuspend(): Couldn't unlock _listMutex %d\n", _listMutex);
+                PSP_ERROR("Couldn't unlock _listMutex[%p]\n", _listMutex);
         }
 
-        PSPDebugSuspend("Out of unregisterSuspend\n");
+        PSP_DEBUG_PRINT("Out of unregisterSuspend\n");
         debugPM();
 
+        DEBUG_EXIT_FUNC();
         return 0;
  }
 
@@ -151 +148 @@
 *
 ********************************************/
  PowerManager::~PowerManager() {
-
-#ifdef __PSP_DEBUG_SUSPEND__
+        DEBUG_ENTER_FUNC();
+ 
         PMStatusSet(kDestroyPM);
-#endif
 
         SDL_DestroyCond(_condSuspendable);
         _condSuspendable = 0;
@@ -167 +163 @@
 
         SDL_DestroyMutex(_listMutex);
         _listMutex = 0;
+        
+        DEBUG_EXIT_FUNC();
  }
 
 /*******************************************
@@ -184 +182 @@
 
         if ((pause != _pauseFlagOld) && g_engine) { // Check to see if we have an engine
                 if (pause && _pauseClientState == PowerManager::Unpaused) {
-                        _pauseClientState = PowerManager::Pausing;      // Tell PM we're in the middle of pausing
+                        _pauseClientState = PowerManager::Pausing;              // Tell PM we're in the middle of pausing
                         g_engine->pauseEngine(true);
-                        PSPDebugSuspend("Pausing engine in PowerManager::pollPauseEngine()\n");
+                        PSP_DEBUG_PRINT_FUNC("Pausing engine\n");
                         _pauseClientState = PowerManager::Paused;               // Tell PM we're done pausing
                 }
                 else if (!pause && _pauseClientState == PowerManager::Paused) {
                         g_engine->pauseEngine(false);
-                        PSPDebugSuspend("Unpausing for resume in PowerManager::pollPauseEngine()\n");
+                        PSP_DEBUG_PRINT_FUNC("Unpausing for resume\n");
                         _pauseClientState = PowerManager::Unpaused;     // Tell PM we're in the middle of pausing
                 }
 
@@ -205 +203 @@
 *   Use this for small critical sections where you can easily restore the previous state.
 *
 ********************************************/
- int PowerManager::blockOnSuspend()  {
+int PowerManager::blockOnSuspend()  {
         return beginCriticalSection(true);
 }
 
@@ -216 +214 @@
 *       Make sure to call endCriticalSection or the PSP won't suspend.
 ********************************************/
 
-  int PowerManager::beginCriticalSection(bool justBlock) {
+int PowerManager::beginCriticalSection(bool justBlock) {
+        DEBUG_ENTER_FUNC();
+        
         int ret = NotBlocked;
 
         if (SDL_mutexP(_flagMutex) != 0) {
-                PSPDebugTrace("PowerManager::blockOnSuspend(): Couldn't lock flagMutex %d\n", _flagMutex);
+                PSP_ERROR("PowerManager::blockOnSuspend(): Couldn't lock flagMutex[%p]\n", _flagMutex);
                 ret = Error;
         }
 
         // Check the access flag
         if (_suspendFlag == true) {
-                PSPDebugSuspend("We're being blocked!\n");
+                PSP_DEBUG_PRINT("We're being blocked!\n");
                 debugPM();
                 ret = Blocked;
 
                 // If it's true, we wait for a signal to continue
                 if (SDL_CondWait(_condSuspendable, _flagMutex) != 0) {
-                        PSPDebugTrace("PowerManager::blockOnSuspend(): Couldn't wait on cond %d\n", _condSuspendable);
+                        PSP_DEBUG_PRINT("PowerManager::blockOnSuspend(): Couldn't wait on cond[%p]\n", _condSuspendable);
                 }
 
-                PSPDebugSuspend("We got blocked!!\n");
+                PSP_DEBUG_PRINT("We got blocked!!\n");
                 debugPM();
         }
 
@@ -244 +244 @@
                 _criticalCounter++;
 
         if (SDL_mutexV(_flagMutex) != 0) {
-                PSPDebugTrace("PowerManager::blockOnSuspend(): Couldn't unlock flagMutex %d\n", _flagMutex);
+                PSP_ERROR("PowerManager::blockOnSuspend(): Couldn't unlock flagMutex[%p]\n", _flagMutex);
                 ret = Error;
         }
 
+        DEBUG_EXIT_FUNC();
         return ret;
 }
 
 int PowerManager::endCriticalSection() {
+        DEBUG_ENTER_FUNC();
         int ret = 0;
 
         if (SDL_mutexP(_flagMutex) != 0) {
-                PSPDebugTrace("PowerManager::endCriticalSection(): Couldn't lock flagMutex %d\n", _flagMutex);
+                PSP_ERROR("PowerManager::endCriticalSection(): Couldn't lock flagMutex[%p]\n", _flagMutex);
                 ret = Error;
         }
 
@@ -264 +266 @@
 
         if (_criticalCounter <= 0) {
                 if (_suspendFlag == true) {     // If the PM is sleeping, this flag must be set
-                        PSPDebugSuspend("Unblocked thread waking up the PM.\n");
+                        PSP_DEBUG_PRINT("Unblocked thread waking up the PM.\n");
                         debugPM();
 
                         SDL_CondBroadcast(_condPM);
 
-                        PSPDebugSuspend("Woke up the PM\n");
+                        PSP_DEBUG_PRINT("Woke up the PM\n");
                         debugPM();
                 }
 
                 if (_criticalCounter < 0) {     // Check for bad usage of critical sections
-                        PSPDebugTrace("PowerManager::endCriticalSection(): Error! Critical counter is %d\n", _criticalCounter);
+                        PSP_ERROR("Critical counter[%d]\n", _criticalCounter);
                         debugPM();
                 }
         }
 
         if (SDL_mutexV(_flagMutex) != 0) {
-                PSPDebugTrace("PowerManager::endCriticalSection(): Couldn't unlock flagMutex %d\n", _flagMutex);
+                PSP_ERROR("Couldn't unlock flagMutex[%p]\n", _flagMutex);
                 ret = Error;
         }
 
+        DEBUG_EXIT_FUNC();
         return ret;
 }
 
@@ -293 +296 @@
 *
 ********************************************/
 int PowerManager::suspend() {
+        DEBUG_ENTER_FUNC();
         int ret = 0;
 
         if (_pauseFlag) return ret;     // Very important - make sure we only suspend once
@@ -325 +329 @@
         // Now we set the suspend flag to true to cause reading threads to block
 
         if (SDL_mutexP(_flagMutex) != 0) {
-                PSPDebugTrace("PowerManager::suspend(): Couldn't lock flagMutex %d\n", _flagMutex);
+                PSP_ERROR("Couldn't lock flagMutex[%p]\n", _flagMutex);
                 _error = Error;
                 ret = Error;
         }
@@ -342 +346 @@
         }
 
         if (SDL_mutexV(_flagMutex) != 0) {
-                PSPDebugTrace("PowerManager::suspend(): Couldn't unlock flagMutex %d\n", _flagMutex);
+                PSP_ERROR("Couldn't unlock flagMutex[%p]\n", _flagMutex);
                 _error = Error;
                 ret = Error;
         }
@@ -351 +355 @@
 
         // Loop over list, calling suspend()
         if (SDL_mutexP(_listMutex) != 0) {
-                PSPDebugTrace("PowerManager::suspend(): Couldn't lock listMutex %d\n", _listMutex);
+                PSP_ERROR("Couldn't lock listMutex[%p]\n", _listMutex);
                 _error = Error;
                 ret = Error;
         }
         PMStatusSet(kIteratingListSuspend);
         // Iterate
-        Common::List<Suspendable *>::iterator i = _suspendList.begin();
+        Common::List<Suspendable *>::iterator i;
 
-        for (; i != _suspendList.end(); ++i) {
+        for (i = _suspendList.begin(); i != _suspendList.end(); ++i) {
                 (*i)->suspend();
         }
 
         PMStatusSet(kDoneIteratingListSuspend);
 
         if (SDL_mutexV(_listMutex) != 0) {
-                PSPDebugTrace("PowerManager::suspend(): Couldn't unlock listMutex %d\n", _listMutex);
+                PSP_ERROR("Couldn't unlock listMutex[%p]\n", _listMutex);
                 _error = Error;
                 ret = Error;
         }
@@ -374 +378 @@
 
         scePowerUnlock(0);                              // Allow the PSP to go to sleep now
 
+        DEBUG_EXIT_FUNC();
         return ret;
 }
 
@@ -383 +388 @@
 *
 ********************************************/
 int PowerManager::resume() {
+        DEBUG_ENTER_FUNC();
         int ret = 0;
 
         // Make sure we can't get another suspend
@@ -394 +400 @@
 
         // First we notify our Suspendables. Loop over list, calling resume()
         if (SDL_mutexP(_listMutex) != 0) {
-                PSPDebugTrace("PowerManager::resume(): Couldn't lock listMutex %d\n", _listMutex);
+                PSP_ERROR("Couldn't lock listMutex[%p]\n", _listMutex);
                 _error = Error;
                 ret = Error;
         }
@@ -409 +415 @@
         PMStatusSet(kDoneIteratingListResume);
 
         if (SDL_mutexV(_listMutex) != 0) {
-                PSPDebugTrace("PowerManager::resume(): Couldn't unlock listMutex %d\n", _listMutex);
+                PSP_ERROR("Couldn't unlock listMutex[%p]\n", _listMutex);
                 _error = Error;
                 ret = Error;
         }
@@ -418 +424 @@
 
         // Now we set the suspend flag to false
         if (SDL_mutexP(_flagMutex) != 0) {
-                PSPDebugTrace("PowerManager::resume(): Couldn't lock flagMutex %d\n", _flagMutex);
+                PSP_ERROR("Couldn't lock flagMutex %p\n", _flagMutex);
                 _error = Error;
                 ret = Error;
         }
@@ -430 +436 @@
 
         // Signal the other threads to wake up
         if (SDL_CondBroadcast(_condSuspendable) != 0) {
-                PSPDebugTrace("PowerManager::resume(): Couldn't broadcast condition %d\n", _condSuspendable);
+                PSP_ERROR("Couldn't broadcast condition[%p]\n", _condSuspendable);
                 _error = Error;
                 ret = Error;
         }
         PMStatusSet(kDoneSignallingSuspendedThreadsResume);
 
         if (SDL_mutexV(_flagMutex) != 0) {
-                PSPDebugTrace("PowerManager::resume(): Couldn't unlock flagMutex %d\n", _flagMutex);
+                PSP_ERROR("Couldn't unlock flagMutex[%p]\n", _flagMutex);
                 _error = Error;
                 ret = Error;
         }
@@ -447 +453 @@
 
         scePowerUnlock(0);      // Allow new suspends
 
+        DEBUG_EXIT_FUNC();
         return ret;
 }

backends/platform/psp/Makefile

@@ -66 +66 @@
 #CC      = psp-gcc
 CXX      = psp-g++
 CXXFLAGS = -O3 -Wall -Wno-multichar -fno-exceptions -fno-rtti
-DEFINES  = -D__PSP__ -DNONSTANDARD_PORT -DDISABLE_TEXT_CONSOLE -DDISABLE_COMMAND_LINE -DUSE_ZLIB -DDISABLE_DOSBOX_OPL
+DEFINES  = -D__PSP__ -DNONSTANDARD_PORT -DDISABLE_TEXT_CONSOLE -DDISABLE_COMMAND_LINE -DUSE_ZLIB -DDISABLE_DOSBOX_OPL -DUSE_RGB_COLOR
 LDFLAGS  :=
 INCDIR   := $(srcdir) . $(srcdir)/engines/ $(PSPSDK)/include
 INCLUDES := $(addprefix -I, $(INCDIR))
@@ -133 +133 @@
 OBJS := powerman.o \
         psp_main.o \
         osys_psp.o \
+        psppixelformat.o \
+        memory.o \
+        display_manager.o \
+        display_client.o \
+        default_display_client.o \
+        input.o \
+        cursor.o \
         trace.o \
         psploader.o \
         pspkeyboard.o

backends/platform/psp/trace.cpp

@@ -23 +23 @@
  *
  */
 
+#define TRACE_C
+#include <pspkernel.h>
+#include <pspdebug.h>
+#include "backends/platform/psp/trace.h"
 
-#include "./trace.h"
 
+int psp_debug_indent = 0;
 
-
-void PSPDebugTrace (const char *format, ...) {
-#ifdef __PSP_DEBUG__
+void PSPDebugTrace (bool alsoToScreen, const char *format, ...) {
         va_list opt;
-        char            buff[2048];
-        int                     bufsz, fd;
+        char            buffer[2048];
+        int                     bufsz;
+        FILE *fd = 0;
 
         va_start(opt, format);
-        bufsz = vsnprintf( buff, (size_t) sizeof(buff), format, opt);
+        bufsz = vsnprintf( buffer, (size_t) sizeof(buffer), format, opt);
         va_end(opt);
 
-        fd = sceIoOpen("MS0:/DTRACE.TXT", PSP_O_RDWR | PSP_O_CREAT | PSP_O_APPEND, 0777);
-
-        if (fd <= 0)
+        //fd = fopen("MS0:/SCUMMTRACE.TXT", "ab");
+        fd = fopen("SCUMMTRACE.TXT", "ab");
+        
+        if (fd == 0)
                 return;
 
-        sceIoWrite(fd, (const void*)buff, bufsz);
-        sceIoClose(fd);
-#endif /* __PSP_DEBUG__ */
+        fwrite(buffer, 1, bufsz, fd);
+        fclose(fd);
+        
+        if (alsoToScreen)
+                fprintf(stderr, buffer);
 }
-
-void PSPDebugTrace (const char * filename, const char *format, ...) {
-#ifdef __PSP_DEBUG__
-        va_list opt;
-        char            buff[2048];
-        int                     bufsz, fd;
-
-        va_start(opt, format);
-        bufsz = vsnprintf( buff, (size_t) sizeof(buff), format, opt);
-        va_end(opt);
-
-        fd = sceIoOpen(filename, PSP_O_RDWR | PSP_O_CREAT | PSP_O_APPEND, 0777);
-
-        if (fd <= 0)
-                return;
-
-        sceIoWrite(fd, (const void*)buff, bufsz);
-        sceIoClose(fd);
-#endif /* __PSP_DEBUG__ */
-}

backends/platform/psp/display_manager.cpp

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $
+ * $Id: osys_psp.cpp 47541 2010-01-25 01:39:44Z lordhoto $
+ *
+ */
+
+//#define __PSP_DEBUG_FUNCS__   /* For debugging function calls */
+//#define __PSP_DEBUG_PRINT__   /* For debug printouts */
+
+//#define ENABLE_RENDER_MEASURE
+
+#include "backends/platform/psp/trace.h"
+
+#include <pspgu.h>
+#include <pspdisplay.h>
+
+#include "common/scummsys.h"
+#include "backends/base-backend.h"
+#include "backends/platform/psp/display_client.h"
+#include "backends/platform/psp/default_display_client.h"
+#include "backends/platform/psp/cursor.h"
+#include "backends/platform/psp/pspkeyboard.h"
+#include "backends/platform/psp/display_manager.h"
+
+#define PSP_BUFFER_WIDTH (512)
+#define PSP_SCREEN_WIDTH        480
+#define PSP_SCREEN_HEIGHT       272
+#define PSP_FRAME_SIZE (PSP_BUFFER_WIDTH * PSP_SCREEN_HEIGHT)
+
+uint32 __attribute__((aligned(16))) MasterGuRenderer::_displayList[2048];
+
+ const OSystem::GraphicsMode DisplayManager::_supportedModes[] = {
+        { "320x200 (centered)", "320x200 16-bit centered", CENTERED_320X200 },
+        { "435x272 (best-fit, centered)", "435x272 16-bit centered", CENTERED_435X272 },
+        { "480x272 (full screen)", "480x272 16-bit stretched", STRETCHED_480X272 },
+        { "362x272 (4:3, centered)", "362x272 16-bit centered", CENTERED_362X272 },
+        {0, 0, 0}
+};
+
+
+// Class MasterGuRenderer ----------------------------------------------
+
+void MasterGuRenderer::guInit() {
+        DEBUG_ENTER_FUNC();
+        
+        sceGuInit();
+        sceGuStart(0, _displayList);
+        
+        guProgramDisplayBufferSizes();
+        
+        sceGuOffset(2048 - (PSP_SCREEN_WIDTH/2), 2048 - (PSP_SCREEN_HEIGHT/2));
+        sceGuViewport(2048, 2048, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT);
+        sceGuDepthRange(0xC350, 0x2710);
+        sceGuDisable(GU_DEPTH_TEST);    // We'll use depth buffer area
+        sceGuDepthMask(GU_TRUE);                // Prevent writes to depth buffer
+        sceGuScissor(0, 0, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT);
+        sceGuEnable(GU_SCISSOR_TEST);
+        sceGuFrontFace(GU_CW);
+        sceGuEnable(GU_TEXTURE_2D);
+
+        sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT);
+        sceGuFinish();
+        sceGuSync(0,0);
+
+        sceDisplayWaitVblankStart();
+        sceGuDisplay(1);
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void MasterGuRenderer::guProgramDisplayBufferSizes() {
+        DEBUG_ENTER_FUNC();
+
+        PSP_DEBUG_PRINT("Outputbits[%u]\n", GuRenderer::_displayManager->getOutputBitsPerPixel());
+        
+        switch (GuRenderer::_displayManager->getOutputBitsPerPixel()) {
+        case 16:
+                sceGuDrawBuffer(GU_PSM_4444, (void *)0, PSP_BUFFER_WIDTH);
+                sceGuDispBuffer(PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT, (void*)(PSP_FRAME_SIZE * sizeof(uint16)), PSP_BUFFER_WIDTH);
+                sceGuDepthBuffer((void*)(PSP_FRAME_SIZE * sizeof(uint16) * 2), PSP_BUFFER_WIDTH);
+                VramAllocator::instance().allocate(PSP_FRAME_SIZE * sizeof(uint16) * 2);
+                break;
+        case 32:
+                sceGuDrawBuffer(GU_PSM_8888, (void *)0, PSP_BUFFER_WIDTH);
+                sceGuDispBuffer(PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT, (void*)(PSP_FRAME_SIZE * sizeof(uint32)), PSP_BUFFER_WIDTH);
+                sceGuDepthBuffer((void*)(PSP_FRAME_SIZE * sizeof(uint32) * 2), PSP_BUFFER_WIDTH);
+                VramAllocator::instance().allocate(PSP_FRAME_SIZE * sizeof(uint32) * 2);
+                break;
+        }
+        
+        DEBUG_EXIT_FUNC();
+}
+
+// These are GU commands that should always stay the same
+INLINE void MasterGuRenderer::guPreRender() {
+        DEBUG_ENTER_FUNC();
+
+#ifdef ENABLE_RENDER_MEASURE
+        _lastRenderTime = g_system->getMillis();
+#endif /* ENABLE_RENDER_MEASURE */      
+        
+        sceGuStart(0, _displayList);
+
+        sceGuClearColor(0xFF000000);
+        sceGuClear(GU_COLOR_BUFFER_BIT);
+        
+        sceGuAmbientColor(0xFFFFFFFF);
+        sceGuColor(0xFFFFFFFF);
+        sceGuTexOffset(0,0);
+        sceGuTexFilter(GU_LINEAR, GU_LINEAR);
+        
+        sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA); // Also good enough for all purposes
+        sceGuAlphaFunc(GU_GREATER, 0, 0xFF);       // Also good enough for all purposes
+        
+        DEBUG_EXIT_FUNC();
+}
+
+INLINE void MasterGuRenderer::guPostRender() {
+        DEBUG_ENTER_FUNC();
+        
+        sceGuFinish();
+        sceGuSync(0,0);
+
+#ifdef ENABLE_RENDER_MEASURE
+        uint32 now = g_system->getMillis();
+        PSP_INFO_PRINT("Render took %d milliseconds\n", now - _lastRenderTime);
+#endif /* ENABLE_RENDER_MEASURE */
+        
+        sceDisplayWaitVblankStart();
+        sceGuSwapBuffers();
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void MasterGuRenderer::guShutDown() {
+        sceGuTerm();
+}
+
+
+// Class DisplayManager -----------------------------------------------------
+
+DisplayManager::~DisplayManager() {
+        _masterGuRenderer.guShutDown();
+}
+
+void DisplayManager::init() {
+        DEBUG_ENTER_FUNC();
+        
+        _displayParams.outputBitsPerPixel = 32; // can be changed to produce 16-bit output
+        
+        GuRenderer::setDisplayManager(this);
+        _screen->init();
+        _overlay->init();
+        _cursor->init();
+        
+        _masterGuRenderer.guInit();                             // start up the renderer
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void DisplayManager::setSizeAndPixelFormat(uint width, uint height, const Graphics::PixelFormat *format) {
+
+        DEBUG_ENTER_FUNC();
+        PSP_DEBUG_PRINT("w[%u], h[%u], pformat[%p]\n", width, height, format);
+
+        _overlay->deallocate();
+        _screen->deallocate();
+        
+        _screen->setScummvmPixelFormat(format);
+        _screen->setSize(width, height);
+        _screen->allocate();
+        
+        _cursor->setScreenPaletteScummvmPixelFormat(format);
+
+        _overlay->setBytesPerPixel(sizeof(OverlayColor));
+        _overlay->setSize(PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT);
+        _overlay->allocate();
+        
+        _displayParams.screenSource.width = width;
+        _displayParams.screenSource.height = height;
+        calculateScaleParams();
+        
+        DEBUG_EXIT_FUNC();
+}
+
+bool DisplayManager::setGraphicsMode(const char *name) {
+        DEBUG_ENTER_FUNC();
+
+        int i = 0;
+
+        while (_supportedModes[i].name) {
+                if (!strcmpi(_supportedModes[i].name, name)) {
+                        setGraphicsMode(_supportedModes[i].id);
+                        DEBUG_EXIT_FUNC();
+                        return true;
+                }
+                i++;
+        }
+
+        DEBUG_EXIT_FUNC();
+        return false;
+}
+
+bool DisplayManager::setGraphicsMode(int mode) {
+        DEBUG_ENTER_FUNC();
+
+        _graphicsMode = mode;
+
+        switch (_graphicsMode) {
+        case CENTERED_320X200:
+                _displayParams.screenOutput.width = 320;
+                _displayParams.screenOutput.height = 200;
+                break;
+        case CENTERED_435X272:
+                _displayParams.screenOutput.width = 435;
+                _displayParams.screenOutput.height = 272;
+                break;
+        case STRETCHED_480X272:
+                _displayParams.screenOutput.width = 480;
+                _displayParams.screenOutput.height = 272;
+                break;
+        case CENTERED_362X272:
+                _displayParams.screenOutput.width = 362;
+                _displayParams.screenOutput.height = 272;
+                break;
+        default:
+                PSP_ERROR("Unsupported graphics mode[%d].\n", _graphicsMode);
+        }
+        
+        calculateScaleParams();
+        
+        DEBUG_EXIT_FUNC();
+        return true;
+}
+
+void DisplayManager::calculateScaleParams() {
+        if (_displayParams.screenOutput.width && _displayParams.screenSource.width &&
+            _displayParams.screenOutput.height && _displayParams.screenSource.height) {
+                _displayParams.scaleX = ((float)_displayParams.screenOutput.width) / _displayParams.screenSource.width;
+                _displayParams.scaleY = ((float)_displayParams.screenOutput.height) / _displayParams.screenSource.height;
+        }
+}
+
+void DisplayManager::renderAll() {
+        DEBUG_ENTER_FUNC();
+
+        if (!isTimeToUpdate()) {
+                DEBUG_EXIT_FUNC();
+                return;
+        }
+
+        if (!_screen->isDirty() && 
+                (!_overlay->isDirty()) && 
+                (!_cursor->isDirty()) && 
+                (!_keyboard->isDirty())) {
+                PSP_DEBUG_PRINT("Nothing dirty\n");
+                DEBUG_EXIT_FUNC();
+                return;
+        }
+        
+        PSP_DEBUG_PRINT("screen[%s], overlay[%s], cursor[%s], keyboard[%s]\n",
+                _screen->isDirty() ? "true" : "false",
+                _overlay->isDirty() ? "true" : "false",
+                _cursor->isDirty() ? "true" : "false",
+                _keyboard->isDirty() ? "true" : "false"
+                );
+
+        _masterGuRenderer.guPreRender();        // Set up rendering
+
+        _screen->render();
+        
+        _screen->setClean();                            // clean out dirty bit
+
+        if (_overlay->isVisible())
+                _overlay->render();
+                
+        _overlay->setClean();
+                
+        if (_cursor->isVisible())
+                _cursor->render();
+                
+        _cursor->setClean();
+
+        if (_keyboard->isVisible())
+                _keyboard->render();
+                
+        _keyboard->setClean();
+                
+        _masterGuRenderer.guPostRender();
+
+        DEBUG_EXIT_FUNC();
+}
+
+inline bool DisplayManager::isTimeToUpdate() {
+
+#define MAX_FPS 30
+
+        uint32 now = g_system->getMillis();
+        if (now - _lastUpdateTime < (1000 / MAX_FPS))
+                return false;
+
+        _lastUpdateTime = now;
+        return true;
+}
+        
+Common::List<Graphics::PixelFormat> DisplayManager::getSupportedPixelFormats() {
+        Common::List<Graphics::PixelFormat> list;
+        
+        // In order of preference
+        list.push_back(PSPPixelFormat::convertToScummvmPixelFormat(PSPPixelFormat::Type_5650));
+        list.push_back(PSPPixelFormat::convertToScummvmPixelFormat(PSPPixelFormat::Type_5551));
+        list.push_back(PSPPixelFormat::convertToScummvmPixelFormat(PSPPixelFormat::Type_4444));
+        list.push_back(Graphics::PixelFormat::createFormatCLUT8());
+        
+        return list;
+}
+

backends/platform/psp/input.h

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $
+ * $Id: osys_psp.cpp 43618 2009-08-21 22:44:49Z joostp $
+ *
+ */ 
+
+#ifndef PSP_INPUT_H
+#define PSP_INPUT_H
+
+#include "common/scummsys.h"
+#include "common/events.h"
+#include "backends/platform/psp/display_client.h"
+#include "backends/platform/psp/default_display_client.h"
+#include "backends/platform/psp/pspkeyboard.h"
+#include "backends/platform/psp/cursor.h"
+#include <pspctrl.h>
+
+class InputHandler {
+public:
+        InputHandler() : _cursor(0), _keyboard(0), _prevButtons(0), _lastPadCheckTime(0), _buttonsChanged(0), _dpadX(0), _dpadY(0) {}
+        
+        void init();
+        bool getAllInputs(Common::Event &event);
+        void setKeyboard(PSPKeyboard *keyboard) { _keyboard = keyboard; }
+        void setCursor(Cursor *cursor) { _cursor = cursor; }
+
+private:
+        Cursor *_cursor;
+        PSPKeyboard *_keyboard;
+        uint32  _prevButtons;
+        uint32  _lastPadCheckTime;
+        uint32 _buttonsChanged;
+        int32 _dpadX, _dpadY;
+        int32 _accelX, _accelY;
+        
+        bool getEvent(Common::Event &event, SceCtrlData &pad);
+        bool getDpadEvent(Common::Event &event, SceCtrlData &pad);
+        bool getButtonEvent(Common::Event &event, SceCtrlData &pad);
+        bool getNubEvent(Common::Event &event, SceCtrlData &pad);       
+        int32 modifyNubAxisMotion(int32 input);
+        Common::KeyCode translateDpad(int x, int y);
+};
+
+#endif /* PSP_INPUT_H */

backends/platform/psp/default_display_client.cpp

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.h $
+ * $Id: osys_psp.h 46120 2009-11-24 10:33:30Z Bluddy $
+ *
+ */
+
+#include "common/scummsys.h"
+#include "backends/platform/psp/display_client.h"
+#include "backends/platform/psp/default_display_client.h"
+
+//#define __PSP_DEBUG_FUNCS__   /* For debugging the stack */
+//#define __PSP_DEBUG_PRINT__
+
+#include "backends/platform/psp/trace.h"
+
+// Class DefaultDisplayClient ---------------------------------------------
+
+bool DefaultDisplayClient::allocate(bool bufferInVram /* = false */, bool paletteInVram /* = false */) {
+        DEBUG_ENTER_FUNC();
+        
+        if (!_buffer.allocate(bufferInVram)) {
+                        PSP_ERROR("Couldn't allocate buffer.\n");
+                        DEBUG_EXIT_FUNC();
+                        return false;
+                }
+
+        if (_buffer.hasPalette())
+        {
+                PSP_DEBUG_PRINT("_palette[%p]\n", &_palette);
+
+                if (!_palette.allocate()) {
+                        PSP_ERROR("Couldn't allocate pallette.\n");
+                        DEBUG_EXIT_FUNC();
+                        return false;
+                }
+        }
+        
+        DEBUG_EXIT_FUNC();
+        return true;
+}
+
+void DefaultDisplayClient::deallocate() {
+        _buffer.deallocate();
+        if (_buffer.hasPalette())
+                _palette.deallocate();
+}
+
+
+void DefaultDisplayClient::clearBuffer() {
+        DEBUG_ENTER_FUNC();
+        _buffer.clear();
+        setDirty();
+        DEBUG_EXIT_FUNC();
+}
+
+inline void DefaultDisplayClient::clearPalette() {
+        DEBUG_ENTER_FUNC();
+        _palette.clear();
+        setDirty();
+        DEBUG_EXIT_FUNC();
+}
+
+void DefaultDisplayClient::init() {
+        DEBUG_ENTER_FUNC();
+        _renderer.setBuffer(&_buffer);
+        _renderer.setPalette(&_palette);
+        DEBUG_EXIT_FUNC();
+}
+
+void DefaultDisplayClient::copyFromRect(const byte *buf, int pitch, int destX, int destY, int recWidth, int recHeight) {
+        DEBUG_ENTER_FUNC();
+        _buffer.copyFromRect(buf, pitch, destX, destY, recWidth, recHeight); 
+        setDirty();
+        DEBUG_EXIT_FUNC();
+}
+
+void DefaultDisplayClient::copyToArray(byte *dst, int pitch) { 
+        DEBUG_ENTER_FUNC();
+        _buffer.copyToArray(dst, pitch);
+        DEBUG_EXIT_FUNC();
+}
+
+// Class Overlay -------------------------------------------------------
+
+void Overlay::init() {
+        DEBUG_ENTER_FUNC();
+
+        DefaultDisplayClient::init();
+        _renderer.setAlphaBlending(true);
+        _renderer.setColorTest(false);
+        _renderer.setUseGlobalScaler(false);
+        _renderer.setFullScreen(true);  // speeds up render slightly
+
+        DEBUG_EXIT_FUNC();
+}
+
+void Overlay::setBytesPerPixel(uint32 size) {
+        DEBUG_ENTER_FUNC();
+        
+        switch (size) {
+        case 1:
+                _buffer.setPixelFormat(PSPPixelFormat::Type_Palette_8bit);
+                _palette.setPixelFormats(PSPPixelFormat::Type_4444, PSPPixelFormat::Type_Palette_8bit);
+                break;
+        case 2:
+                _buffer.setPixelFormat(PSPPixelFormat::Type_4444);
+                break;
+        case 4:
+                _buffer.setPixelFormat(PSPPixelFormat::Type_8888);
+                break;
+        }
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void Overlay::setSize(uint32 width, uint32 height) {
+        DEBUG_ENTER_FUNC();
+        _buffer.setSize(width, height, Buffer::kSizeBySourceSize);
+        _renderer.setDrawWholeBuffer(); // We need to let the renderer know how much to draw
+        DEBUG_EXIT_FUNC();
+}
+
+void Overlay::copyToArray(OverlayColor *buf, int pitch) {
+        DEBUG_ENTER_FUNC();
+        _buffer.copyToArray((byte *)buf, pitch * sizeof(OverlayColor)); // Change to bytes
+        DEBUG_EXIT_FUNC();
+}
+
+void Overlay::copyFromRect(const OverlayColor *buf, int pitch, int x, int y, int w, int h) {
+        DEBUG_ENTER_FUNC();
+        
+        _buffer.copyFromRect((byte *)buf, pitch * sizeof(OverlayColor), x, y, w, h);    // Change to bytes
+        // debug
+        //_buffer.print(0xFF);
+        setDirty();
+        DEBUG_EXIT_FUNC();
+}
+
+bool Overlay::allocate() {
+        DEBUG_ENTER_FUNC();
+        
+        bool ret = DefaultDisplayClient::allocate(true, false); // buffer in VRAM
+        
+        DEBUG_EXIT_FUNC();
+        return ret;
+}
+
+// Class Screen -----------------------------------------------------------
+
+void Screen::init() {
+        DEBUG_ENTER_FUNC();
+
+        DefaultDisplayClient::init();
+        _renderer.setAlphaBlending(false);
+        _renderer.setColorTest(false);
+        _renderer.setUseGlobalScaler(true);
+        _renderer.setFullScreen(true);
+
+        DEBUG_EXIT_FUNC();
+}
+
+void Screen::setShakePos(int pos) {
+        _shakePos = pos; 
+        _renderer.setOffsetOnScreen(0, pos);
+        setDirty();
+}
+
+void Screen::setSize(uint32 width, uint32 height) {
+        DEBUG_ENTER_FUNC();
+
+        _buffer.setSize(width, height, Buffer::kSizeBySourceSize);
+        _renderer.setDrawWholeBuffer(); // We need to let the renderer know how much to draw
+        
+        DEBUG_EXIT_FUNC();
+}
+
+void Screen::setScummvmPixelFormat(const Graphics::PixelFormat *format) {
+        DEBUG_ENTER_FUNC();
+        PSP_DEBUG_PRINT("format[%p], _buffer[%p], _palette[%p]\n", format, &_buffer, &_palette);
+
+        if (!format) {
+                bzero(&_pixelFormat, sizeof(_pixelFormat));
+                _pixelFormat.bytesPerPixel = 1; // default
+        } else {
+                _pixelFormat = *format;
+        }
+        
+        PSPPixelFormat::Type bufferFormat, paletteFormat;
+        bool swapRedBlue = false;
+        
+        PSPPixelFormat::convertFromScummvmPixelFormat(format, bufferFormat, paletteFormat, swapRedBlue);
+        _buffer.setPixelFormat(bufferFormat, swapRedBlue);
+        _palette.setPixelFormats(paletteFormat, bufferFormat, swapRedBlue);
+        
+        DEBUG_EXIT_FUNC();
+}
+
+Graphics::Surface *Screen::lockAndGetForEditing() {
+        DEBUG_ENTER_FUNC();
+        
+        _frameBuffer.pixels = _buffer.getPixels();
+        _frameBuffer.w = _buffer.getSourceWidth();
+        _frameBuffer.h = _buffer.getSourceHeight();
+        _frameBuffer.pitch = _buffer.getBytesPerPixel() * _buffer.getWidth();
+        _frameBuffer.bytesPerPixel = _buffer.getBytesPerPixel();
+        // We'll set to dirty once we unlock the screen
+        
+        DEBUG_EXIT_FUNC();
+        
+        return &_frameBuffer;
+}
+
+bool Screen::allocate() {
+        DEBUG_ENTER_FUNC();
+        
+        return DefaultDisplayClient::allocate(true, false);     // buffer in VRAM
+        
+        DEBUG_EXIT_FUNC();
+}

backends/platform/psp/display_client.h

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $
+ * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $
+ *
+ */
+ 
+#ifndef PSP_GRAPHICS_H
+#define PSP_GRAPHICS_H
+
+#include "common/singleton.h"
+#include "graphics/surface.h"
+#include "common/system.h"
+#include "backends/platform/psp/psppixelformat.h"
+#include "backends/platform/psp/memory.h"
+ 
+#define MAX_TEXTURE_SIZE 512 
+
+class DisplayManager;
+class GuRenderer;
+
+/**
+ *      Interface to inherit for all display clients
+ *      We deliberately avoid virtual functions for speed.
+ */
+class DisplayClient {                           // Abstract class
+public:
+        DisplayClient() {}
+        bool isVisible() { return true; }
+        bool isDirty() { return true; }
+        void setClean() {}
+        void render() {}
+        virtual ~DisplayClient() {}
+};
+ 
+/**
+ * Vertex used for GU rendering
+ */
+struct Vertex {
+        float u,v;
+        float x,y,z;
+};
+
+struct Point {
+        int x;
+        int y;
+        Point() : x(0), y(0) {}
+};
+
+/**
+ * Dimensions struct for simplification
+ */
+struct Dimensions {
+        uint32 width;
+        uint32 height;
+        Dimensions() : width(0), height(0) {}
+};
+
+/**
+ *      Universal PSP Palette class
+ *      Use this in any class that wishes to draw to the PSP screen.
+ *      Use together with GuRenderer
+ */
+class Palette {
+public:
+        Palette() : _values(0), _numOfEntries(0) {}
+        virtual ~Palette() { deallocate(); }
+        bool allocate();
+        void deallocate();
+        void clear();
+        void setPixelFormats(PSPPixelFormat::Type paletteType, PSPPixelFormat::Type bufferType, bool swapRedBlue = false);
+        void setNumOfEntries(uint32 num) {      _numOfEntries = num; }
+        uint32 getNumOfEntries() { return _numOfEntries; }
+        uint32 getSizeInBytes() { return _pixelFormat.pixelsToBytes(_numOfEntries); }
+        void set(byte *values) { setPartial(values, 0, _numOfEntries); }
+        void setPartial(const byte *colors, uint start, uint num, bool supportsAlpha = false);
+        void getPartial(byte *colors, uint start, uint num);
+        uint32 getRawColorAt(uint32 position);
+        uint32 getRGBAColorAt(uint32 position);
+        void setSingleColorRGBA(uint32 num, byte r, byte g, byte b, byte a);
+        void setColorPositionAlpha(uint32 position, bool alpha);
+        byte *getRawValues() { return _values; }
+        bool isAllocated() { return (_values != 0); }
+        PSPPixelFormat::Type getPixelFormat() { return _pixelFormat.format; }
+        void print(uint32 numToPrint = 0);                                      // print to screen
+        
+protected:
+        byte *_values;                                  ///< array of palette data
+        uint32 _numOfEntries;                   ///< number of palette entries
+        PSPPixelFormat _pixelFormat;    ///< pixel format of the palette data
+};
+
+/**
+ *      Universal PSP buffer/texture object
+ *      Use this in any class that wishes to draw to the PSP screen.
+ *      Use together with GuRenderer
+ */
+class Buffer {
+public:
+        enum HowToSize {
+                kSizeByTextureSize,     // buffer size is determined by power of 2 roundup for texture
+                kSizeBySourceSize       // buffer size is determined by source size
+        };
+
+        Buffer() : _pixels(0), _width(0), _height(0)  {}
+        virtual ~Buffer() { deallocate(); }
+        
+        // setters
+        void setSize(uint32 width, uint32 height, HowToSize textureOrSource=kSizeByTextureSize);
+        void setBitsPerPixel(uint32 bits) { _pixelFormat.bitsPerPixel = bits; }
+        void setBytesPerPixel(uint32 bytes) { setBitsPerPixel(bytes << 3); }
+        void setPixelFormat(PSPPixelFormat::Type type, bool swapRedBlue = false);
+
+        // getters
+        uint32 getWidth() { return _width; }
+        uint32 getWidthInBytes() { return _pixelFormat.pixelsToBytes(getWidth()); }
+        uint32 getHeight() { return _height; }
+        uint32 getSourceWidth() { return _sourceSize.width; }
+        uint32 getSourceWidthInBytes() { return _pixelFormat.pixelsToBytes(_sourceSize.width); }
+        uint32 getSourceHeight() { return _sourceSize.height; } 
+        uint32 getTextureWidth() { return _textureSize.width; }
+        uint32 getTextureHeight() { return _textureSize.height; }
+        PSPPixelFormat::Type getPixelFormat() { return _pixelFormat.format; }
+        uint32 getBitsPerPixel() { return _pixelFormat.bitsPerPixel; }
+        uint32 getBytesPerPixel() { return getBitsPerPixel() >> 3; } /* won't work for 4-bit */
+        byte *getPixels() { return _pixels; }
+        uint32 getSizeInBytes() { return _pixelFormat.pixelsToBytes(_width * _height); }
+        
+        bool hasPalette();
+        void copyFromArray(const byte *buffer, int pitch);
+        void copyFromRect(const byte *buf, uint32 pitch, int destX, int destY, uint32 recWidth, uint32 recHeight);
+        void copyToArray(byte *dst, int pitch);
+        bool allocate(bool inVram = false);
+        void deallocate();
+        bool isAllocated() { return (_pixels != 0) ; }
+        void clear();
+        void flipNibbles();             // To handle peculiarities of PSP's 4 bit textures
+        static uint32 scaleUpToPowerOfTwo(uint32 size);
+        void print(uint32 mask, uint32 numToPrint = 0);
+        
+protected:
+        friend class GuRenderer;
+        byte *_pixels;
+        uint32 _width;                                  ///< True allocated width
+        uint32 _height;                                 ///< True allocated height
+        Dimensions _textureSize;                ///< Size rounded up to power of 2. Used for drawing
+        Dimensions _sourceSize;                 ///< Original size of the buffer
+        PSPPixelFormat _pixelFormat;    ///< Format of the buffer       
+};
+
+/**
+ *      Universal rendering class for PSP
+ *      Use this if you want to draw to the screen.
+ *      Needs to be supplied with a Buffer and a Palette
+ */
+class GuRenderer {
+public:
+        // Constructors
+        GuRenderer() : _useGlobalScaler(false), _buffer(0), _palette(0), _blending(false), _alphaReverse(false), _colorTest(false), _keyColor(0), _fullScreen(false) {}
+        GuRenderer(Buffer *buffer, Palette *palette) : _useGlobalScaler(false), _buffer(buffer), _palette(palette), _blending(false), _alphaReverse(false), _colorTest(false), _keyColor(0), _fullScreen(false) {}
+        static void setDisplayManager(DisplayManager *dm) { _displayManager = dm; } // Called by the Display Manager
+        
+        // Setters
+        void setDrawSize(uint32 width, uint32 height) { // How big of an area to draw
+                        _drawSize.width = width;
+                        _drawSize.height = height;
+        }
+        void setDrawWholeBuffer() {                                             // Draw the full size of the current buffer
+                assert(_buffer);
+                _drawSize.width = _buffer->getSourceWidth();
+                _drawSize.height = _buffer->getSourceHeight();
+        }
+    void setBuffer(Buffer *buffer) { _buffer = buffer; }
+    void setPalette(Palette *palette) { _palette = palette; }
+        void setMaxTextureOffsetByIndex(uint32 x, uint32 y);    // For drawing multiple textures
+        void setOffsetOnScreen(uint32 x, uint32 y) { _offsetOnScreen.x = x; _offsetOnScreen.y = y; }
+        void setOffsetInBuffer(uint32 x, uint32 y) { _offsetInBuffer.x = x; _offsetInBuffer.y = y; }
+        void setColorTest(bool value) { _colorTest = value; }
+        void setKeyColor(uint32 value) { _keyColor = _buffer->_pixelFormat.convertTo32BitColor(value); }
+        void setAlphaBlending(bool value) { _blending = value; }
+        void setAlphaReverse(bool value) { _alphaReverse = value; }
+        void setFullScreen(bool value) { _fullScreen = value; }         // Shortcut for rendering
+        void setUseGlobalScaler(bool value) { _useGlobalScaler = value; }       // Scale to screen
+        
+        static void cacheInvalidate(void *pointer, uint32 size);
+        
+        void render();                                                  // Default rendering function. This should be good enough for most purposes
+
+protected:
+        // Gu functions
+        void fillVertices(Vertex *vertices);    // Fill in vertices with coordinates
+        void guProgramDrawBehavior();
+        Vertex *guGetVertices();
+        void guLoadTexture();   
+        void guLoadPalette();
+        void guProgramTextureFormat();
+        void guProgramTextureBitDepth();
+        void guDrawVertices(Vertex *vertices);
+
+        uint32 convertToGuPixelFormat(PSPPixelFormat::Type format);
+        float scaleSourceToOutputX(float offset);
+        float scaleSourceToOutputY(float offset);
+        
+        friend class MasterGuRenderer;
+        Point _maxTextureOffset;                ///> For rendering textures > 512 pixels
+        Point _offsetOnScreen;                  ///> Where on screen to draw
+        Point _offsetInBuffer;                  ///> Where in the texture to draw
+        bool _useGlobalScaler;                  ///> Scale to the output size on screen
+        Buffer *_buffer;
+        Palette *_palette;
+        static DisplayManager *_displayManager;
+        Dimensions _drawSize;                   ///> Actual size to draw out of the Buffer
+        bool _blending;
+        bool _alphaReverse;                             ///> 0 counts as full alpha
+        bool _colorTest;
+        uint32 _keyColor;                               ///> Color to test against for color test. in 32 bits.
+        bool _fullScreen;                               ///> Speeds up for fullscreen rendering
+};
+
+#endif /* PSP_SCREEN_H */

backends/platform/psp/memory.h

@@ +1 @@
+
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $
+ * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $
+ *
+ */
+
+#ifndef PSP_MEMORY_H
+#define PSP_MEMORY_H 
+
+#define UNCACHED(x)             ((byte *)(((uint32)(x)) | 0x40000000))  /* make an uncached access */
+#define CACHED(x)               ((byte *)(((uint32)(x)) & 0xBFFFFFFF))  /* make an uncached access into a cached one */
+ 
+/**
+ *      Class that does memory copying and swapping if needed
+ */
+class Copier {
+public:
+        static void copy(byte *dst, const byte *src, uint32 bytes, PSPPixelFormat *format = NULL);
+        static void copy8(byte *dst, const byte *src, uint32 bytes);
+        static void copy16(uint16 *dst, const uint16 *src, uint32 bytes, PSPPixelFormat *format = NULL);
+};
+
+/**
+ *      Class that allocates memory in the VRAM
+ */
+class VramAllocator : public Common::Singleton<VramAllocator> {
+public:
+        VramAllocator() : _bytesAllocated(0) {}
+        void *allocate(int32 size, bool smallAllocation = false);       // smallAllocation e.g. palettes
+        void deallocate(void *pointer);
+
+        static inline bool isAddressInVram(void *address) {
+        if ((uint32)(CACHED(address)) >= VRAM_START_ADDRESS && (uint32)(CACHED(address)) < VRAM_END_ADDRESS)
+                return true;
+        return false;
+}
+
+
+private:
+        /**
+         *      Used to allocate in VRAM
+         */
+        struct Allocation {
+                byte *address;
+                uint32 size;
+                void *getEnd() { return address + size; }
+                Allocation(void *Address, uint32 Size) : address((byte *)Address), size(Size) {}
+                Allocation() : address(0), size(0) {}
+        };
+
+        enum {
+                VRAM_START_ADDRESS = 0x04000000,
+                VRAM_END_ADDRESS   = 0x04200000,
+                VRAM_SMALL_ADDRESS = VRAM_END_ADDRESS - (4*1024)        // 4K in the end for small allocations
+        };
+        Common::List <Allocation> _allocList;           // List of allocations
+        uint32 _bytesAllocated;
+};
+ 
+#endif /* PSP_MEMORY_H */

backends/platform/psp/osys_psp.cpp

@@ -23 +23 @@
  *
  */
 
+#include <pspuser.h> 
 #include <pspgu.h>
 #include <pspdisplay.h>
 
@@ -33 +34 @@
 #include "common/events.h"
 #include "common/scummsys.h"
 
-#include "osys_psp.h"
-#include "trace.h"
-#include "powerman.h"
+#include "backends/platform/psp/osys_psp.h"
+#include "backends/platform/psp/powerman.h"
 
 #include "backends/saves/psp/psp-saves.h"
 #include "backends/timer/default/default-timer.h"
 #include "graphics/surface.h"
 #include "sound/mixer_intern.h"
 
-#include "backends/platform/psp/pspkeyboard.h"
+//#define __PSP_DEBUG_FUNCS__   /* For debugging function calls */
+//#define __PSP_DEBUG_PRINT__   /* For debug printouts */
 
+#include "backends/platform/psp/trace.h"
 
+
 #define SAMPLES_PER_SEC 44100
 
-#define PIXEL_SIZE (4)
-#define BUF_WIDTH (512)
-#define PSP_SCREEN_WIDTH        480
-#define PSP_SCREEN_HEIGHT       272
-#define PSP_FRAME_SIZE (BUF_WIDTH * PSP_SCREEN_HEIGHT * PIXEL_SIZE)
-#define MOUSE_SIZE      128
-#define KBD_DATA_SIZE   130560
-
-#define MAX_FPS 30
-
-unsigned int __attribute__((aligned(16))) displayList[2048];
-unsigned short __attribute__((aligned(16))) clut256[256];
-unsigned short __attribute__((aligned(16))) mouseClut[256];
-unsigned short __attribute__((aligned(16))) cursorPalette[256];
-unsigned int __attribute__((aligned(16))) mouseBuf256[MOUSE_SIZE*MOUSE_SIZE];
-
-
-unsigned long RGBToColour(unsigned long r, unsigned long g, unsigned long b) {
-        return (((b >> 3) << 10) | ((g >> 3) << 5) | ((r >> 3) << 0)) | 0x8000;
-}
-
 static int timer_handler(int t) {
         DefaultTimerManager *tm = (DefaultTimerManager *)g_system->getTimerManager();
         tm->handler();
         return t;
 }
 
-const OSystem::GraphicsMode OSystem_PSP::s_supportedGraphicsModes[] = {
-        { "320x200 (centered)", "320x200 16-bit centered", CENTERED_320X200 },
-        { "435x272 (best-fit, centered)", "435x272 16-bit centered", CENTERED_435X272 },
-        { "480x272 (full screen)", "480x272 16-bit stretched", STRETCHED_480X272 },
-        { "362x272 (4:3, centered)", "362x272 16-bit centered", CENTERED_362X272 },
-        {0, 0, 0}
-};
+void OSystem_PSP::initSDL() {
+        SDL_Init(SDL_INIT_AUDIO | SDL_INIT_TIMER);
+}
 
+OSystem_PSP::~OSystem_PSP() {}
 
-OSystem_PSP::OSystem_PSP() : _screenWidth(0), _screenHeight(0), _overlayWidth(0), _overlayHeight(0),
-                _offscreen(0), _overlayBuffer(0), _overlayVisible(false), _shakePos(0), _lastScreenUpdate(0),
-                _mouseBuf(0), _prevButtons(0), _lastPadCheck(0), _mixer(0) {
-        memset(_palette, 0, sizeof(_palette));
+#define PSP_SCREEN_WIDTH 480
+#define PSP_SCREEN_HEIGHT 272
 
-        _cursorPaletteDisabled = true;
+void OSystem_PSP::initBackend() {
+        DEBUG_ENTER_FUNC();
 
-        //init SDL
-        uint32  sdlFlags = SDL_INIT_AUDIO | SDL_INIT_TIMER;
-        SDL_Init(sdlFlags);
+        _cursor.enableCursorPalette(false);
+        _cursor.setXY(PSP_SCREEN_WIDTH >> 1, PSP_SCREEN_HEIGHT >> 1);   // Mouse in the middle of the screen
+        
+        // Set pointers for display manager
+        _displayManager.setCursor(&_cursor);
+        _displayManager.setScreen(&_screen);
+        _displayManager.setOverlay(&_overlay);
+        _displayManager.setKeyboard(&_keyboard);
+        _displayManager.init();
 
-        _clut = clut256;
-        _mouseBuf = (byte *)mouseBuf256;
-        _graphicMode = STRETCHED_480X272;
+        // Set pointers for input handler
+        _inputHandler.setCursor(&_cursor);
+        _inputHandler.setKeyboard(&_keyboard);
+        _inputHandler.init();
 
-        _mouseX = PSP_SCREEN_WIDTH >> 1;        // Mouse in the middle of the screen
-        _mouseY = PSP_SCREEN_HEIGHT >> 1;
-        _dpadX = _dpadY = 0;
+        initSDL();              
 
-
-        // Init GU
-        sceGuInit();
-        sceGuStart(0, displayList);
-        sceGuDrawBuffer(GU_PSM_8888, (void *)0, BUF_WIDTH);
-        sceGuDispBuffer(PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT, (void*)PSP_FRAME_SIZE, BUF_WIDTH);
-        sceGuDepthBuffer((void*)(PSP_FRAME_SIZE * 2), BUF_WIDTH);
-        sceGuOffset(2048 - (PSP_SCREEN_WIDTH/2), 2048 - (PSP_SCREEN_HEIGHT/2));
-        sceGuViewport(2048, 2048, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT);
-        sceGuDepthRange(0xC350, 0x2710);
-        sceGuScissor(0, 0, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT);
-        sceGuEnable(GU_SCISSOR_TEST);
-        sceGuFrontFace(GU_CW);
-        sceGuEnable(GU_TEXTURE_2D);
-        sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT);
-        sceGuFinish();
-        sceGuSync(0,0);
-
-        sceDisplayWaitVblankStart();
-        sceGuDisplay(1);
-
-}
-
-OSystem_PSP::~OSystem_PSP() {
-
-        free(_offscreen);
-        free(_overlayBuffer);
-        free(_mouseBuf);
-        delete _keyboard;
-
-        _offscreen = 0;
-        _overlayBuffer = 0;
-        _mouseBuf = 0;
-         sceGuTerm();
-}
-
-
-void OSystem_PSP::initBackend() {
         _savefile = new PSPSaveFileManager;
 
         _timer = new DefaultTimerManager();
 
-        _keyboard = new PSPKeyboard();
-        _keyboard->load();
-
+        PSP_DEBUG_PRINT("calling keyboard.load()\n");
+        _keyboard.load();       // Load virtual keyboard files into memory
+        
         setTimerCallback(&timer_handler, 10);
 
         setupMixer();
 
         OSystem::initBackend();
+        
+        DEBUG_EXIT_FUNC();
 }
 
-
 bool OSystem_PSP::hasFeature(Feature f) {
         return (f == kFeatureOverlaySupportsAlpha || f == kFeatureCursorHasPalette);
 }
@@ -167 +113 @@
 }
 
 const OSystem::GraphicsMode* OSystem_PSP::getSupportedGraphicsModes() const {
-        return s_supportedGraphicsModes;
+        return _displayManager.getSupportedGraphicsModes();
 }
 
-
 int OSystem_PSP::getDefaultGraphicsMode() const {
-        return STRETCHED_480X272;
+        DEBUG_ENTER_FUNC();
+
+        int ret = _displayManager.getDefaultGraphicsMode();
+
+        DEBUG_EXIT_FUNC();
+        return ret;
 }
 
 bool OSystem_PSP::setGraphicsMode(int mode) {
-        _graphicMode = mode;
-        return true;
+        DEBUG_ENTER_FUNC();
+        
+        int ret = _displayManager.setGraphicsMode(mode);
+        
+        DEBUG_EXIT_FUNC();
+        return ret;
 }
 
 bool OSystem_PSP::setGraphicsMode(const char *name) {
-        int i = 0;
-
-        while (s_supportedGraphicsModes[i].name) {
-                if (!strcmpi(s_supportedGraphicsModes[i].name, name)) {
-                        _graphicMode = s_supportedGraphicsModes[i].id;
-                        return true;
-                }
-                i++;
-        }
-
-        return false;
+        DEBUG_ENTER_FUNC();
+        
+        int ret = _displayManager.setGraphicsMode(name);
+        
+        DEBUG_EXIT_FUNC();
+        return ret;
 }
 
 int OSystem_PSP::getGraphicsMode() const {
-        return _graphicMode;
+        DEBUG_ENTER_FUNC();
+        
+        int ret = _displayManager.getGraphicsMode();
+        
+        DEBUG_EXIT_FUNC();
+        return ret;
 }
 
-void OSystem_PSP::initSize(uint width, uint height, const Graphics::PixelFormat *format) {
-        PSPDebugTrace("initSize\n");
+#ifdef USE_RGB_COLOR
 
-        _screenWidth = width;
-        _screenHeight = height;
+Graphics::PixelFormat OSystem_PSP::getScreenFormat() const {
+        return _screen.getScummvmPixelFormat();
+}
 
-        const int scrBufSize = _screenWidth * _screenHeight * (format ? format->bytesPerPixel : 4);
+Common::List<Graphics::PixelFormat> OSystem_PSP::getSupportedFormats() {
+        return _displayManager.getSupportedPixelFormats();
+}
 
-        _overlayWidth = PSP_SCREEN_WIDTH;       //width;
-        _overlayHeight = PSP_SCREEN_HEIGHT;     //height;
+#endif
 
-        free(_overlayBuffer);
-        _overlayBuffer = (OverlayColor *)memalign(16, _overlayWidth * _overlayHeight * sizeof(OverlayColor));
+void OSystem_PSP::initSize(uint width, uint height, const Graphics::PixelFormat *format) {
+        DEBUG_ENTER_FUNC();
+        
+        _displayManager.setSizeAndPixelFormat(width, height, format);
 
-        free(_offscreen);
-        _offscreen = (byte *)memalign(16, scrBufSize);
-        bzero(_offscreen, scrBufSize);
+        _cursor.setVisible(false);
+        _cursor.setLimits(_screen.getWidth(), _screen.getHeight());
 
-        clearOverlay();
-        memset(_palette, 0xFFFF, 256 * sizeof(unsigned short));
-
-        _mouseVisible = false;
-        sceKernelDcacheWritebackAll();
+        DEBUG_EXIT_FUNC();
 }
 
 int16 OSystem_PSP::getWidth() {
-        return _screenWidth;
+        DEBUG_ENTER_FUNC();
+
+        int16 ret = (int16)_screen.getWidth();
+        
+        DEBUG_EXIT_FUNC();
+        return ret;
 }
 
 int16 OSystem_PSP::getHeight() {
-        return _screenHeight;
+        DEBUG_ENTER_FUNC();
+
+        int16 ret = (int16)_screen.getHeight();
+        
+        DEBUG_EXIT_FUNC();
+        return ret;
 }
 
 void OSystem_PSP::setPalette(const byte *colors, uint start, uint num) {
-        const byte *b = colors;
+        DEBUG_ENTER_FUNC();
+        
+        _screen.setPartialPalette(colors, start, num);
+        _cursor.setScreenPalette(colors, start, num);
+        _cursor.clearKeyColor();
 
-        for (uint i = 0; i < num; ++i) {
-                _palette[start + i] = RGBToColour(b[0], b[1], b[2]);
-                b += 4;
-        }
-
-        //copy to CLUT
-        memcpy(_clut, _palette, 256 * sizeof(unsigned short));
-
-        //force update of mouse CLUT as well, as it may have been set up before this palette was set
-        memcpy(mouseClut, _palette, 256 * sizeof(unsigned short));
-        mouseClut[_mouseKeyColour] = 0;
-
-        sceKernelDcacheWritebackAll();
+        DEBUG_EXIT_FUNC();
 }
 
 void OSystem_PSP::setCursorPalette(const byte *colors, uint start, uint num) {
-        const byte *b = colors;
+        DEBUG_ENTER_FUNC();
 
-        for (uint i = 0; i < num; ++i) {
-                cursorPalette[start + i] = RGBToColour(b[0], b[1], b[2]);
-                b += 4;
-        }
+        _cursor.setCursorPalette(colors, start, num);
+        _cursor.enableCursorPalette(true);
+        _cursor.clearKeyColor();        // Do we need this?
 
-        cursorPalette[0] = 0;
-
-        _cursorPaletteDisabled = false;
-
-        sceKernelDcacheWritebackAll();
+        DEBUG_EXIT_FUNC();
 }
 
 void OSystem_PSP::disableCursorPalette(bool disable) {
-        _cursorPaletteDisabled = disable;
+        DEBUG_ENTER_FUNC();
+
+        _cursor.enableCursorPalette(!disable);
+        
+        DEBUG_EXIT_FUNC();
 }
 
 void OSystem_PSP::copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h) {
-        //Clip the coordinates
-        if (x < 0) {
-                w += x;
-                buf -= x;
-                x = 0;
-        }
+        DEBUG_ENTER_FUNC();
 
-        if (y < 0) {
-                h += y;
-                buf -= y * pitch;
-                y = 0;
-        }
+        _screen.copyFromRect(buf, pitch, x, y, w, h);
 
-        if (w > _screenWidth - x) {
-                w = _screenWidth - x;
-        }
-
-        if (h > _screenHeight - y) {
-                h = _screenHeight - y;
-        }
-
-        if (w <= 0 || h <= 0)
-                return;
-
-
-        byte *dst = _offscreen + y * _screenWidth + x;
-
-        if (_screenWidth == pitch && pitch == w) {
-                memcpy(dst, buf, h * w);
-        } else {
-                do {
-                        memcpy(dst, buf, w);
-                        buf += pitch;
-                        dst += _screenWidth;
-                } while (--h);
-        }
-        sceKernelDcacheWritebackAll();
-
+        DEBUG_EXIT_FUNC();
 }
 
 Graphics::Surface *OSystem_PSP::lockScreen() {
-        _framebuffer.pixels = _offscreen;
-        _framebuffer.w = _screenWidth;
-        _framebuffer.h = _screenHeight;
-        _framebuffer.pitch = _screenWidth;
-        _framebuffer.bytesPerPixel = 1;
+        DEBUG_ENTER_FUNC();
 
-        return &_framebuffer;
+        Graphics::Surface *ret = _screen.lockAndGetForEditing();        
+        
+        DEBUG_EXIT_FUNC();
+        return ret;
 }
 
 void OSystem_PSP::unlockScreen() {
-        // The screen is always completely update anyway, so we don't have to force a full update here.
-        sceKernelDcacheWritebackAll();
+        DEBUG_ENTER_FUNC();
+        // The screen is always completely updated anyway, so we don't have to force a full update here.
+        _screen.unlock();
+        
+        DEBUG_EXIT_FUNC();
 }
 
 void OSystem_PSP::updateScreen() {
-        u32 now = getMillis();
-        if (now - _lastScreenUpdate < 1000 / MAX_FPS)
-                return;
+        DEBUG_ENTER_FUNC();
 
-        _lastScreenUpdate = now;
-
-        sceGuStart(0, displayList);
-
-        sceGuClearColor(0xFF000000);
-        sceGuClear(GU_COLOR_BUFFER_BIT);
-
-        sceGuClutMode(GU_PSM_5551, 0, 0xFF, 0);
-        sceGuClutLoad(32, clut256); // upload 32*8 entries (256)
-        sceGuTexMode(GU_PSM_T8, 0, 0, 0); // 8-bit image
-        if (_screenWidth == 320)
-                sceGuTexImage(0, 512, 256, _screenWidth, _offscreen);
-        else
-                sceGuTexImage(0, 512, 512, _screenWidth, _offscreen);
-        sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB);
-        sceGuTexFilter(GU_LINEAR, GU_LINEAR);
-        sceGuTexOffset(0,0);
-        sceGuAmbientColor(0xFFFFFFFF);
-        sceGuColor(0xFFFFFFFF);
-
-        Vertex *vertices = (Vertex *)sceGuGetMemory(2 * sizeof(Vertex));
-        vertices[0].u = 0.5f;
-        vertices[0].v = 0.5f;
-        vertices[1].u = _screenWidth - 0.5f;
-        vertices[1].v = _screenHeight - 0.5f;
-
-        switch (_graphicMode) {
-                case CENTERED_320X200:
-                        vertices[0].x = (PSP_SCREEN_WIDTH - 320) / 2;
-                        vertices[0].y = (PSP_SCREEN_HEIGHT - 200) / 2;
-                        vertices[0].z = 0;
-                        vertices[1].x = PSP_SCREEN_WIDTH - (PSP_SCREEN_WIDTH - 320) / 2;
-                        vertices[1].y = PSP_SCREEN_HEIGHT - (PSP_SCREEN_HEIGHT - 200) / 2;
-                        vertices[1].z = 0;
-                break;
-                case CENTERED_435X272:
-                        vertices[0].x = (PSP_SCREEN_WIDTH - 435) / 2;
-                        vertices[0].y = 0; vertices[0].z = 0;
-                        vertices[1].x = PSP_SCREEN_WIDTH - (PSP_SCREEN_WIDTH - 435) / 2;
-                        vertices[1].y = PSP_SCREEN_HEIGHT;
-                        vertices[1].z = 0;
-                break;
-                case STRETCHED_480X272:
-                        vertices[0].x = 0;
-                        vertices[0].y = 0;
-                        vertices[0].z = 0;
-                        vertices[1].x = PSP_SCREEN_WIDTH;
-                        vertices[1].y = PSP_SCREEN_HEIGHT;
-                        vertices[1].z = 0;
-                break;
-                case CENTERED_362X272:
-                        vertices[0].x = (PSP_SCREEN_WIDTH - 362) / 2;
-                        vertices[0].y = 0;
-                        vertices[0].z = 0;
-                        vertices[1].x = PSP_SCREEN_WIDTH - (PSP_SCREEN_WIDTH - 362) / 2;
-                        vertices[1].y = PSP_SCREEN_HEIGHT;
-                        vertices[1].z = 0;
-                break;
-        }
-
-        if (_shakePos) {
-                vertices[0].y += _shakePos;
-                vertices[1].y += _shakePos;
-        }
-
-        sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2, 0, vertices);
-        if (_screenWidth == 640) {
-                // 2nd draw
-                Vertex *vertices2 = (Vertex *)sceGuGetMemory(2 * sizeof(Vertex));
-                sceGuTexImage(0, 512, 512, _screenWidth, _offscreen+512);
-                vertices2[0].u = 512 + 0.5f;
-                vertices2[0].v = vertices[0].v;
-                vertices2[1].u = vertices[1].u;
-                vertices2[1].v = _screenHeight - 0.5f;
-                vertices2[0].x = vertices[0].x + (vertices[1].x - vertices[0].x) * 511 / 640;
-                vertices2[0].y = 0;
-                vertices2[0].z = 0;
-                vertices2[1].x = vertices[1].x;
-                vertices2[1].y = vertices[1].y;
-                vertices2[1].z = 0;
-                sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2, 0, vertices2);
-        }
-
-
-        // draw overlay
-        if (_overlayVisible) {
-                Vertex *vertOverlay = (Vertex *)sceGuGetMemory(2 * sizeof(Vertex));
-                vertOverlay[0].x = 0;
-                vertOverlay[0].y = 0;
-                vertOverlay[0].z = 0;
-                vertOverlay[1].x = PSP_SCREEN_WIDTH;
-                vertOverlay[1].y = PSP_SCREEN_HEIGHT;
-                vertOverlay[1].z = 0;
-                vertOverlay[0].u = 0.5f;
-                vertOverlay[0].v = 0.5f;
-                vertOverlay[1].u = _overlayWidth - 0.5f;
-                vertOverlay[1].v = _overlayHeight - 0.5f;
-                sceGuTexMode(GU_PSM_4444, 0, 0, 0); // 16-bit image
-                sceGuDisable(GU_ALPHA_TEST);
-                sceGuEnable(GU_BLEND);
-
-                //sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0);
-                sceGuBlendFunc(GU_ADD, GU_FIX, GU_ONE_MINUS_SRC_ALPHA, 0xFFFFFFFF, 0);
-
-                if (_overlayWidth > 320)
-                        sceGuTexImage(0, 512, 512, _overlayWidth, _overlayBuffer);
-                else
-                        sceGuTexImage(0, 512, 256, _overlayWidth, _overlayBuffer);
-
-                sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
-                sceGuDrawArray(GU_SPRITES,GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D,2,0,vertOverlay);
-                // need to render twice for textures > 512
-                if ( _overlayWidth > 512) {
-                        Vertex *vertOverlay2 = (Vertex *)sceGuGetMemory(2 * sizeof(Vertex));
-                        sceGuTexImage(0, 512, 512, _overlayWidth, _overlayBuffer + 512);
-                        vertOverlay2[0].u = 512 + 0.5f;
-                        vertOverlay2[0].v = vertOverlay[0].v;
-                        vertOverlay2[1].u = vertOverlay[1].u;
-                        vertOverlay2[1].v = _overlayHeight - 0.5f;
-                        vertOverlay2[0].x = PSP_SCREEN_WIDTH * 512 / 640;
-                        vertOverlay2[0].y = 0;
-                        vertOverlay2[0].z = 0;
-                        vertOverlay2[1].x = PSP_SCREEN_WIDTH;
-                        vertOverlay2[1].y = PSP_SCREEN_HEIGHT;
-                        vertOverlay2[1].z = 0;
-                        sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2, 0, vertOverlay2);
-                }
-                sceGuDisable(GU_BLEND);
-        }
-
-        // draw mouse
-        if (_mouseVisible) {
-                sceGuTexMode(GU_PSM_T8, 0, 0, 0); // 8-bit image
-                sceGuClutMode(GU_PSM_5551, 0, 0xFF, 0);
-                sceGuClutLoad(32, _cursorPaletteDisabled ? mouseClut : cursorPalette); // upload 32*8 entries (256)
-                sceGuAlphaFunc(GU_GREATER, 0, 0xFF);
-                sceGuEnable(GU_ALPHA_TEST);
-                sceGuTexImage(0, MOUSE_SIZE, MOUSE_SIZE, MOUSE_SIZE, _mouseBuf);
-                sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);
-
-                Vertex *vertMouse = (Vertex *)sceGuGetMemory(2 * sizeof(Vertex));
-                vertMouse[0].u = 0.5f;
-                vertMouse[0].v = 0.5f;
-                vertMouse[1].u = _mouseWidth - 0.5f;
-                vertMouse[1].v = _mouseHeight - 0.5f;
-
-                //adjust cursor position
-                int mX = _mouseX - _mouseHotspotX;
-                int mY = _mouseY - _mouseHotspotY;
-
-                if (_overlayVisible) {
-                        float scalex, scaley;
-
-                        scalex = (float)PSP_SCREEN_WIDTH /_overlayWidth;
-                        scaley = (float)PSP_SCREEN_HEIGHT /_overlayHeight;
-
-                        vertMouse[0].x = mX * scalex;
-                        vertMouse[0].y = mY * scaley;
-                        vertMouse[0].z = 0;
-                        vertMouse[1].x = vertMouse[0].x + _mouseWidth * scalex;
-                        vertMouse[1].y = vertMouse[0].y + _mouseHeight * scaley;
-                        vertMouse[1].z = 0;
-                } else
-                        switch (_graphicMode) {
-                        case CENTERED_320X200:
-                                vertMouse[0].x = (PSP_SCREEN_WIDTH - 320) / 2 + mX;
-                                vertMouse[0].y = (PSP_SCREEN_HEIGHT - 200) / 2 + mY;
-                                vertMouse[0].z = 0;
-                                vertMouse[1].x = vertMouse[0].x + _mouseWidth;
-                                vertMouse[1].y = vertMouse[0].y + _mouseHeight;
-                                vertMouse[1].z = 0;
-                        break;
-                        case CENTERED_435X272:
-                        {
-                                float scalex, scaley;
-
-                                scalex = 435.0f / _screenWidth;
-                                scaley = 272.0f / _screenHeight;
-
-                                vertMouse[0].x = (PSP_SCREEN_WIDTH - 435) / 2 + mX * scalex;
-                                vertMouse[0].y = mY * scaley;
-                                vertMouse[0].z = 0;
-                                vertMouse[1].x = vertMouse[0].x + _mouseWidth * scalex;
-                                vertMouse[1].y = vertMouse[0].y + _mouseHeight * scaley;
-                                vertMouse[1].z = 0;
-                        }
-                        break;
-                        case CENTERED_362X272:
-                        {
-                                float scalex, scaley;
-
-                                scalex = 362.0f / _screenWidth;
-                                scaley = 272.0f / _screenHeight;
-
-                                vertMouse[0].x = (PSP_SCREEN_WIDTH - 362) / 2 + mX * scalex;
-                                vertMouse[0].y = mY * scaley;
-                                vertMouse[0].z = 0;
-                                vertMouse[1].x = vertMouse[0].x + _mouseWidth * scalex;
-                                vertMouse[1].y = vertMouse[0].y + _mouseHeight * scaley;
-                                vertMouse[1].z = 0;
-                        }
-                        break;
-                        case STRETCHED_480X272:
-                        {
-                                float scalex, scaley;
-
-                                scalex = (float)PSP_SCREEN_WIDTH / _screenWidth;
-                                scaley = (float)PSP_SCREEN_HEIGHT / _screenHeight;
-
-                                vertMouse[0].x = mX * scalex;
-                                vertMouse[0].y = mY * scaley;
-                                vertMouse[0].z = 0;
-                                vertMouse[1].x = vertMouse[0].x + _mouseWidth * scalex;
-                                vertMouse[1].y = vertMouse[0].y + _mouseHeight * scaley;
-                                vertMouse[1].z = 0;
-                        }
-                        break;
-                }
-                sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2, 0, vertMouse);
-        }
-
-        if (_keyboard->isVisible()) {
-                _keyboard->render();
-        }
-
-        sceGuFinish();
-        sceGuSync(0,0);
-
-        sceDisplayWaitVblankStart();
-        sceGuSwapBuffers();
+        _displayManager.renderAll();
+        
+        DEBUG_EXIT_FUNC();
 }
 
 void OSystem_PSP::setShakePos(int shakeOffset) {
-        _shakePos = shakeOffset;
+        DEBUG_ENTER_FUNC();     
+
+        _screen.setShakePos(shakeOffset);
+        
+        DEBUG_EXIT_FUNC();      
 }
 
 void OSystem_PSP::showOverlay() {
-        _overlayVisible = true;
+        DEBUG_ENTER_FUNC();
+
+        _overlay.setVisible(true);
+        _cursor.setLimits(_overlay.getWidth(), _overlay.getHeight());
+        _cursor.useGlobalScaler(false); // mouse with overlay is 1:1
+        
+        DEBUG_EXIT_FUNC();
 }
 
 void OSystem_PSP::hideOverlay() {
-        PSPDebugTrace("OSystem_PSP::hideOverlay called\n");
-        _overlayVisible = false;
+        DEBUG_ENTER_FUNC();
+
+        _overlay.setVisible(false);
+        _cursor.setLimits(_screen.getWidth(), _screen.getHeight());
+        _cursor.useGlobalScaler(true);  // mouse needs to be scaled with screen
+        
+        DEBUG_EXIT_FUNC();
 }
 
 void OSystem_PSP::clearOverlay() {
-        PSPDebugTrace("clearOverlay\n");
+        DEBUG_ENTER_FUNC();
 
-        bzero(_overlayBuffer, _overlayWidth * _overlayHeight * sizeof(OverlayColor));
-        sceKernelDcacheWritebackAll();
+        _overlay.clearBuffer();
+
+        DEBUG_EXIT_FUNC();
 }
 
 void OSystem_PSP::grabOverlay(OverlayColor *buf, int pitch) {
-        int h = _overlayHeight;
-        OverlayColor *src = _overlayBuffer;
+        DEBUG_ENTER_FUNC();
 
-        do {
-                memcpy(buf, src, _overlayWidth * sizeof(OverlayColor));
-                src += _overlayWidth;
-                buf += pitch;
-        } while (--h);
+        _overlay.copyToArray(buf, pitch);
+
+        DEBUG_EXIT_FUNC();
 }
 
 void OSystem_PSP::copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h) {
-        PSPDebugTrace("copyRectToOverlay\n");
+        DEBUG_ENTER_FUNC();
 
-        //Clip the coordinates
-        if (x < 0) {
-                w += x;
-                buf -= x;
-                x = 0;
-        }
+        _overlay.copyFromRect(buf, pitch, x, y, w, h);
 
-        if (y < 0) {
-                h += y;
-                buf -= y * pitch;
-                y = 0;
-        }
-
-        if (w > _overlayWidth - x) {
-                w = _overlayWidth - x;
-        }
-
-        if (h > _overlayHeight - y) {
-                h = _overlayHeight - y;
-        }
-
-        if (w <= 0 || h <= 0)
-                return;
-
-
-        OverlayColor *dst = _overlayBuffer + (y * _overlayWidth + x);
-
-        if (_overlayWidth == pitch && pitch == w) {
-                memcpy(dst, buf, h * w * sizeof(OverlayColor));
-        } else {
-                do {
-                        memcpy(dst, buf, w * sizeof(OverlayColor));
-                        buf += pitch;
-                        dst += _overlayWidth;
-                } while (--h);
-        }
-        sceKernelDcacheWritebackAll();
+        DEBUG_EXIT_FUNC();
 }
 
 int16 OSystem_PSP::getOverlayWidth() {
-        return _overlayWidth;
+        return (int16) _overlay.getWidth();
 }
 
 int16 OSystem_PSP::getOverlayHeight() {
-        return _overlayHeight;
+        return (int16) _overlay.getHeight();
 }
 
-
 void OSystem_PSP::grabPalette(byte *colors, uint start, uint num) {
-        uint i;
-        uint16 color;
+        DEBUG_ENTER_FUNC();
 
-        for (i = start; i < start + num; i++) {
-                color = _palette[i];
-                *colors++ = ((color & 0x1F) << 3);
-                *colors++ = (((color >> 5) & 0x1F) << 3);
-                *colors++ = (((color >> 10) & 0x1F) << 3);
-                *colors++ = (color & 0x8000 ? 255 : 0);
-        }
+        _screen.getPartialPalette(colors, start, num);
+        
+        DEBUG_EXIT_FUNC();
 }
 
-bool OSystem_PSP::showMouse(bool visible) {
-        bool last = _mouseVisible;
-        _mouseVisible = visible;
+bool OSystem_PSP::showMouse(bool v) {
+        DEBUG_ENTER_FUNC();
+
+        PSP_DEBUG_PRINT("%s\n", v ? "true" : "false");
+        bool last = _cursor.isVisible();
+        _cursor.setVisible(v);
+        
+        DEBUG_EXIT_FUNC();
+        
         return last;
 }
 
 void OSystem_PSP::warpMouse(int x, int y) {
-        //assert(x > 0 && x < _screenWidth);
-        //assert(y > 0 && y < _screenHeight);
-        _mouseX = x;
-        _mouseY = y;
+        DEBUG_ENTER_FUNC();
+
+        _cursor.setXY(x,y);
+        
+        DEBUG_EXIT_FUNC();
 }
 
 void OSystem_PSP::setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format) {
-        //TODO: handle cursorTargetScale
-        _mouseWidth = w;
-        _mouseHeight = h;
+        DEBUG_ENTER_FUNC();
 
-        _mouseHotspotX = hotspotX;
-        _mouseHotspotY = hotspotY;
-
-        _mouseKeyColour = keycolor & 0xFF;
-
-        memcpy(mouseClut, _palette, 256 * sizeof(unsigned short));
-        mouseClut[_mouseKeyColour] = 0;
-
-        for (unsigned int i = 0; i < h; i++)
-                memcpy(_mouseBuf + i * MOUSE_SIZE, buf + i * w, w);
-
-        sceKernelDcacheWritebackAll();
-}
-
-#define PAD_CHECK_TIME  40
-#define PAD_DIR_MASK    (PSP_CTRL_UP | PSP_CTRL_DOWN | PSP_CTRL_LEFT | PSP_CTRL_RIGHT)
-
-bool OSystem_PSP::processInput(Common::Event &event) {
-        s8 analogStepAmountX = 0;
-        s8 analogStepAmountY = 0;
-
-        sceCtrlSetSamplingCycle(0);
-        sceCtrlSetSamplingMode(1);
-        sceCtrlReadBufferPositive(&pad, 1);
-
-        bool usedInput, haveEvent;
-
-        haveEvent = _keyboard->processInput(event, pad, usedInput);
-
-        if (usedInput)  // Check if the keyboard used up the input
-                return haveEvent;
-
-        uint32 buttonsChanged = pad.Buttons ^ _prevButtons;
-
-        int newDpadX = 0, newDpadY = 0;
-        event.kbd.ascii = 0;
-        event.kbd.flags = 0;
-
-        if (pad.Buttons & PSP_CTRL_UP) {
-                newDpadY += 1;
-                if (pad.Buttons & PSP_CTRL_RTRIGGER)
-                        newDpadX += 1;
+        PSP_DEBUG_PRINT("pbuf[%p], w[%u], h[%u], hotspot:X[%d], Y[%d], keycolor[%d], scale[%d], pformat[%p]\n", buf, w, h, hotspotX, hotspotY, keycolor, cursorTargetScale, format);
+        if (format) {
+                PSP_DEBUG_PRINT("format: bpp[%d], rLoss[%d], gLoss[%d], bLoss[%d], aLoss[%d], rShift[%d], gShift[%d], bShift[%d], aShift[%d]\n", format->bytesPerPixel, format->rLoss, format->gLoss, format->bLoss, format->aLoss, format->rShift, format->gShift, format->bShift, format->aShift);
         }
-        if (pad.Buttons & PSP_CTRL_RIGHT) {
-                newDpadX += 1;
-                if (pad.Buttons & PSP_CTRL_RTRIGGER)
-                        newDpadY -= 1;
-        }
-        if (pad.Buttons & PSP_CTRL_DOWN) {
-                newDpadY -= 1;
-                if (pad.Buttons & PSP_CTRL_RTRIGGER)
-                        newDpadX -= 1;
-        }
-        if (pad.Buttons & PSP_CTRL_LEFT) {
-                newDpadX -= 1;
-                if (pad.Buttons & PSP_CTRL_RTRIGGER)
-                        newDpadY += 1;
-        }
-        //fprintf(stderr, "x=%d, y=%d, oldx=%d, oldy=%d\n", newDpadX, newDpadY, _dpadX, _dpadY);
-        if (newDpadX != _dpadX || newDpadY != _dpadY) {
-                if (_dpadX == 0 && _dpadY == 0) {// We pressed dpad
-                        event.type = Common::EVENT_KEYDOWN;
-                        event.kbd.keycode = getDpadEvent(newDpadX, newDpadY);
-                        event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';
-                        _dpadX = newDpadX;
-                        _dpadY = newDpadY;
-                }
-                else if (newDpadX == 0 && newDpadY == 0) {// We unpressed dpad
-                        event.type = Common::EVENT_KEYUP;
-                        event.kbd.keycode = getDpadEvent(_dpadX, _dpadY);
-                        event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';
-                        _dpadX = newDpadX;
-                        _dpadY = newDpadY;
-                } else { // we moved from one pressed dpad to another one
-                        event.type = Common::EVENT_KEYUP;       // first release the last dpad direction
-                        event.kbd.keycode = getDpadEvent(_dpadX, _dpadY);
-                        event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';
-                        _dpadX = 0; // so that we'll pick up a new dpad movement
-                        _dpadY = 0;
-                }
-
-                _prevButtons = pad.Buttons;
-                return true;
-
-        } else if (buttonsChanged & (PSP_CTRL_CROSS | PSP_CTRL_CIRCLE | PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER | PSP_CTRL_START |
-                                                PSP_CTRL_SELECT | PSP_CTRL_SQUARE | PSP_CTRL_TRIANGLE)) {
-                if (buttonsChanged & PSP_CTRL_CROSS) {
-                        event.type = (pad.Buttons & PSP_CTRL_CROSS) ? Common::EVENT_LBUTTONDOWN : Common::EVENT_LBUTTONUP;
-                } else if (buttonsChanged & PSP_CTRL_CIRCLE) {
-                        event.type = (pad.Buttons & PSP_CTRL_CIRCLE) ? Common::EVENT_RBUTTONDOWN : Common::EVENT_RBUTTONUP;
-                } else {
-                        //any of the other buttons.
-                        event.type = buttonsChanged & pad.Buttons ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP;
-
-                        if (buttonsChanged & PSP_CTRL_LTRIGGER) {
-                                event.kbd.keycode = Common::KEYCODE_ESCAPE;
-                                event.kbd.ascii = 27;
-                        } else if (buttonsChanged & PSP_CTRL_START) {
-                                event.kbd.keycode = Common::KEYCODE_F5;
-                                event.kbd.ascii = Common::ASCII_F5;
-                                if (pad.Buttons & PSP_CTRL_RTRIGGER) {
-                                        event.kbd.flags = Common::KBD_CTRL;     // Main menu to allow RTL
-                                }
-/*                      } else if (buttonsChanged & PSP_CTRL_SELECT) {
-                                event.kbd.keycode = Common::KEYCODE_0;
-                                event.kbd.ascii = '0';
-*/                      } else if (buttonsChanged & PSP_CTRL_SQUARE) {
-                                event.kbd.keycode = Common::KEYCODE_PERIOD;
-                                event.kbd.ascii = '.';
-                        } else if (buttonsChanged & PSP_CTRL_TRIANGLE) {
-                                event.kbd.keycode = Common::KEYCODE_RETURN;
-                                event.kbd.ascii = 13;
-                        } else if (pad.Buttons & PSP_CTRL_RTRIGGER) {
-                                event.kbd.flags |= Common::KBD_SHIFT;
-                        }
-
-                }
-
-                event.mouse.x = _mouseX;
-                event.mouse.y = _mouseY;
-                _prevButtons = pad.Buttons;
-                return true;
-        }
-
-        uint32 time = getMillis();
-        if (time - _lastPadCheck > PAD_CHECK_TIME) {
-                _lastPadCheck = time;
-                int16 newX = _mouseX;
-                int16 newY = _mouseY;
-
-                if (pad.Lx < 100) {
-                        analogStepAmountX = pad.Lx - 100;
-                } else if (pad.Lx > 155) {
-                        analogStepAmountX = pad.Lx - 155;
-                }
-
-                if (pad.Ly < 100) {
-                        analogStepAmountY = pad.Ly - 100;
-                } else if (pad.Ly > 155) {
-                        analogStepAmountY = pad.Ly - 155;
-                }
-
-                if (analogStepAmountX != 0 || analogStepAmountY != 0) {
-
-                        _prevButtons = pad.Buttons;
-
-                        // If no movement then this has no effect
-                        if (pad.Buttons & PSP_CTRL_RTRIGGER) {
-                                // Fine control mode for analog
-                                        if (analogStepAmountX != 0) {
-                                                if (analogStepAmountX > 0)
-                                                        newX += 1;
-                                                else
-                                                        newX -= 1;
-                                        }
-
-                                        if (analogStepAmountY != 0) {
-                                                if (analogStepAmountY > 0)
-                                                        newY += 1;
-                                                else
-                                                        newY -= 1;
-                                        }
-                        } else {
-                                newX += analogStepAmountX >> ((_screenWidth == 640) ? 2 : 3);
-                                newY += analogStepAmountY >> ((_screenWidth == 640) ? 2 : 3);
-                        }
-
-                        if (newX < 0)
-                                newX = 0;
-                        if (newY < 0)
-                                newY = 0;
-                        if (_overlayVisible) {
-                                if (newX >= _overlayWidth)
-                                        newX = _overlayWidth - 1;
-                                if (newY >= _overlayHeight)
-                                        newY = _overlayHeight - 1;
-                        } else {
-                                if (newX >= _screenWidth)
-                                        newX = _screenWidth - 1;
-                                if (newY >= _screenHeight)
-                                        newY = _screenHeight - 1;
-                        }
-
-                        if ((_mouseX != newX) || (_mouseY != newY)) {
-                                event.type = Common::EVENT_MOUSEMOVE;
-                                event.mouse.x = _mouseX = newX;
-                                event.mouse.y = _mouseY = newY;
-                                return true;
-                        }
-                }
-        }
-
-        return false;
+        
+        _cursor.setKeyColor(keycolor);  
+        _cursor.setCursorTargetScale(cursorTargetScale);
+        _cursor.setSizeAndScummvmPixelFormat(w, h, format);
+        _cursor.setHotspot(hotspotX, hotspotY);
+        _cursor.clearKeyColor();
+        _cursor.copyFromArray(buf);
+        
+        DEBUG_EXIT_FUNC();
 }
 
-inline Common::KeyCode OSystem_PSP::getDpadEvent(int x, int y) {
-        Common::KeyCode key;
-
-        if (x == -1) {
-                if (y == -1)
-                        key = Common::KEYCODE_KP1;
-                else if (y == 0)
-                        key = Common::KEYCODE_KP4;
-                else /* y == 1 */
-                        key = Common::KEYCODE_KP7;
-        } else if (x == 0) {
-                if (y == -1)
-                        key = Common::KEYCODE_KP2;
-                else /* y == 1 */
-                        key = Common::KEYCODE_KP8;
-        } else {/* x == 1 */
-                if (y == -1)
-                        key = Common::KEYCODE_KP3;
-                else if (y == 0)
-                        key = Common::KEYCODE_KP6;
-                else /* y == 1 */
-                        key = Common::KEYCODE_KP9;
-        }
-
-        return key;
-}
-
 bool OSystem_PSP::pollEvent(Common::Event &event) {
 
         // If we're polling for events, we should check for pausing the engine
@@ -905 +369 @@
 
         PowerMan.pollPauseEngine();
 
-        return processInput(event);
-
+        return _inputHandler.getAllInputs(event);
 }
 
 
@@ -997 +460 @@
 void OSystem_PSP::quit() {
         SDL_CloseAudio();
         SDL_Quit();
-        sceGuTerm();
         sceKernelExitGame();
 }
 

backends/platform/psp/README.PSP.in

@@ -16 +16 @@
 Right trigger                   - Modifier key (see below for uses)
 Analog                                  - Mouse movement
 Right trigger + Analog  - Fine control mouse
-Directionals                    - Mouse movement
+Directions                              - Arrow keys
+Directions + Right Trigger - Diagonal arrow keys
 Triangle                                - Enter
 Cross                                   - Mouse button 1
 Circle                                  - Mouse button 2
 Square                                  - '.' (skip dialogue in some games)
-Start                                   - F5
+Start                                   - F5 (Main Menu)
 Right trigger + Start   - Return-To-Launcher menu
 
 Virtual Keyboard

backends/platform/psp/cursor.h

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.h $
+ * $Id: osys_psp.h 46120 2009-11-24 10:33:30Z Bluddy $
+ *
+ */
+ 
+#ifndef MOUSE_H
+#define MOUSE_H
+
+class Cursor : public DefaultDisplayClient {
+private:
+        int     _hotspotX, _hotspotY;
+        uint32 _keyColor;
+        int _cursorTargetScale;
+        bool _useCursorPalette;
+        bool _hasCursorPalette;
+        uint32  _mouseLimitWidth;
+        uint32  _mouseLimitHeight;
+        int32   _x, _y;
+        Palette _screenPalette;                 // separate palette for screen. default 'palette' is cursor palette.
+        
+        void updateRendererOffset();
+
+public:
+        Cursor() : _hotspotX(0), _hotspotY(0), _keyColor(0), _cursorTargetScale(0), 
+                _useCursorPalette(false), _hasCursorPalette(false), _mouseLimitWidth(0),
+                _mouseLimitHeight(0), _x(0), _y(0) { }
+        virtual ~Cursor() { deallocate(); }
+        
+        void setKeyColor(uint32 color); 
+        void setCursorTargetScale(int scale) { _cursorTargetScale = scale; }
+        void setScreenPalette(const byte *colors, uint start, uint num);
+        void copyFromArray(const byte *array);
+        Palette &palette() { return _palette; }
+        Buffer &buffer() { return _buffer; }
+        void setCursorPalette(const byte *colors, uint start, uint num);
+        void enableCursorPalette(bool enable);
+        void setLimits(uint32 width, uint32 height); 
+        void setXY(int x, int y);
+        int32 getX() { return _x; }
+        int32 getY() { return _y; }
+        bool increaseXY(int32 incX, int32 incY); // returns true if there's a change in x or y
+        void adjustXYForScreenSize(int32 &x, int32 &y);
+        void init();
+        void setHotspot(int32 x, int32 y);
+        void setScreenPaletteScummvmPixelFormat(const Graphics::PixelFormat *format);
+        void setSizeAndScummvmPixelFormat(uint32 widht, uint32 height, const Graphics::PixelFormat *format);
+        void clearKeyColor();
+        void useGlobalScaler(bool val) { _renderer.setUseGlobalScaler(val); }
+        bool allocate();
+        void deallocate();
+        
+private:
+        void setSize(uint32 width, uint32 height);
+        void getPixelFormatsFromScummvmPixelFormat(const Graphics::PixelFormat *format,
+                                                                                                        PSPPixelFormat::Type &bufferFormat,
+                                                                                                        PSPPixelFormat::Type &paletteFormat,
+                                                                                                        uint32 &numOfEntries);
+        void setRendererModePalettized(bool palettized);                                                                                                        
+};
+
+#endif /* MOUSE_H */

backends/platform/psp/psppixelformat.h

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $
+ * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $
+ *
+ */
+
+#ifndef PSP_PIXEL_FORMAT_H 
+#define PSP_PIXEL_FORMAT_H
+ 
+#include "graphics/pixelformat.h"
+#include "backends/platform/psp/trace.h"
+ 
+/**
+ *      Specialized PixelFormat class
+ *  Supports only those formats which the PSP allows, including 4 bit palettes.
+ *  Also provides accurate color conversion (needed for color masking)
+ *  As well as swapping of red and blue channels (needed by HE games, for example)
+ */
+struct PSPPixelFormat{
+        enum Type {
+                Type_None,
+                Type_4444,
+                Type_5551,
+                Type_5650,
+                Type_8888,
+                Type_Palette_8bit,
+                Type_Palette_4bit,
+                Type_Unknown            
+        };
+        
+        Type format;
+        uint32 bitsPerPixel;                                    ///< Must match bpp of selected type
+        bool swapRB;                                                    ///< Swap red and blue values when reading and writing
+
+        PSPPixelFormat() : format(Type_Unknown), bitsPerPixel(0), swapRB(false) {}
+        void set(Type type, bool swap = false);
+        static void convertFromScummvmPixelFormat(const Graphics::PixelFormat *pf,
+                                                                                                PSPPixelFormat::Type &bufferType,
+                                                                                                PSPPixelFormat::Type &paletteType,
+                                                                                                bool &swapRedBlue);
+        static Graphics::PixelFormat convertToScummvmPixelFormat(PSPPixelFormat::Type type);
+        uint32 convertTo32BitColor(uint32 color);
+
+        inline uint32 rgbaToColor(uint32 r, uint32 g, uint32 b, uint32 a) {
+                uint32 color;
+                
+                switch(format) {
+                case Type_4444:
+                        color = (((b >> 4) << 8) | ((g >> 4) << 4) | ((r >> 4) << 0) | ((a >> 4) << 12));
+                        break;
+                case Type_5551:
+                        color = (((b >> 3) << 10) | ((g >> 3) << 5) | ((r >> 3) << 0) | ((a >> 7) << 15));
+                        break;
+                case Type_5650:
+                        color = (((b >> 3) << 11) | ((g >> 2) << 5) | ((r >> 3) << 0));
+                        break;
+                case Type_8888:
+                        color = (((b >> 0) << 16) | ((g >> 0) << 8) | ((r >> 0) << 0) | ((a >> 0) << 24));
+                        break;
+                default:
+                        color = 0;
+                        break;
+                }
+                return color;
+        }
+
+        inline void colorToRgba(uint32 color, uint32 &r, uint32 &g, uint32 &b, uint32 &a) {
+                switch(format) {
+                case Type_4444:
+                        a = (color >> 12) & 0xF; // Interpolate to get true colors
+                        b = (color >> 8)  & 0xF;
+                        g = (color >> 4)  & 0xF;
+                        r = (color >> 0)  & 0xF;
+                        a = a << 4 | a;
+                        b = b << 4 | b;
+                        g = g << 4 | g;
+                        r = r << 4 | r;
+                        break;
+                case Type_5551:
+                        a = (color >> 15) ? 0xFF : 0;
+                        b = (color >> 10) & 0x1F;
+                        g = (color >> 5)  & 0x1F;
+                        r = (color >> 0)  & 0x1F;
+                        b = b << 3 | b >> 2;
+                        g = g << 3 | g >> 2;
+                        r = r << 3 | r >> 2;
+                        break;
+                case Type_5650:
+                        a = 0xFF;
+                        b = (color >> 11) & 0x1F;
+                        g = (color >> 5)  & 0x3F;
+                        r = (color >> 0)  & 0x1F;
+                        b = b << 3 | b >> 2;
+                        g = g << 2 | g >> 4;
+                        r = r << 3 | r >> 2;
+                        break;
+                case Type_8888:
+                        a = (color >> 24) & 0xFF;
+                        b = (color >> 16) & 0xFF;
+                        g = (color >> 8)  & 0xFF;
+                        r = (color >> 0)  & 0xFF;
+                        break;
+                default:
+                        a = b = g = r = 0;
+                        break;
+                }
+        }
+
+        inline uint32 setColorAlpha(uint32 color, byte alpha) {
+                switch(format) {
+                case Type_4444:
+                        color = (color & 0x0FFF) | (((uint32)alpha >> 4) << 12);
+                        break;
+                case Type_5551:
+                        color = (color & 0x7FFF) | (((uint32)alpha >> 7) << 15);
+                        break;
+                case Type_8888:
+                        color = (color & 0x00FFFFFF) | ((uint32)alpha << 24); 
+                        break;
+                case Type_5650:
+                default:
+                        break;
+                }
+                return color;
+        }
+        
+        inline uint32 pixelsToBytes(uint32 pixels) {
+                switch (bitsPerPixel) {
+                case 4:
+                        pixels >>= 1;
+                        break;
+                case 16:
+                        pixels <<= 1;
+                        break;
+                case 32:
+                        pixels <<= 2;
+                        break;
+                case 8:
+                        break;
+                default:
+                        PSP_ERROR("Incorrect bitsPerPixel value[%u]. pixels[%u]\n", bitsPerPixel, pixels);
+                        break;
+                }
+                return pixels;
+        }
+
+        inline uint16 swapRedBlue16(uint16 color) {
+                uint16 output;
+                
+                switch (format) {
+                        case Type_4444:
+                                output = (color & 0xf0f0) | ((color & 0x000f)<<8)  | ((color & 0x0f00)>>8);
+                                break;
+                        case Type_5551:
+                                output = (color & 0x83e0) | ((color & 0x001f)<<10) | ((color & 0x7c00)>>10);
+                                break;
+                        case Type_5650:
+                                output = (color & 0x07e0) | ((color & 0x001f)<<11) | ((color & 0xf800)>>11);
+                                break;
+                        default:
+                                PSP_ERROR("invalid format[%u] for swapping\n", format);
+                                output = 0;
+                                break;
+                }
+                return output;
+        }
+
+        inline uint32 swapRedBlue32(uint32 color) {
+                uint32 output;
+        
+                switch (format) {
+                        case Type_4444:
+                                output = (color & 0xf0f0f0f0) | 
+                                                ((color & 0x000f000f)<<8)  | ((color & 0x0f000f00)>>8);
+                                break;
+                        case Type_5551:
+                                output = (color & 0x83e083e0) | 
+                                                ((color & 0x001f001f)<<10) | ((color & 0x7c007c00)>>10);
+                                break;
+                        case Type_5650:
+                                output = (color & 0x07e007e0) | 
+                                                ((color & 0x001f001f)<<11) | ((color & 0xf800f800)>>11);
+                                break;
+                        case Type_8888:
+                                output = (color & 0xff00ff00) | 
+                                                ((color & 0x000000ff)<<16) | ((color & 0x00ff0000)>>16);
+                                break;                  
+                        default:
+                                PSP_ERROR("invalid format[%u] for swapping\n", format);
+                                output = 0;
+                                break;
+                }
+                
+                return output;
+        }
+
+        // Return whatever color we point at
+        inline uint32 getColorValueAt(byte *pointer) {
+                uint32 result;
+
+                switch (bitsPerPixel) {
+                case 4: // We can't distinguish a 4 bit color with a pointer
+                case 8:
+                        result = (uint32)*pointer;
+                        break;
+                case 16:
+                        result = (uint32)*(uint16 *)pointer;
+                        break;
+                case 32:
+                        result = *(uint32 *)pointer;
+                        break;
+                default:
+                        result = 0;
+                        PSP_ERROR("Incorrect bitsPerPixel value[%u].\n", bitsPerPixel);
+                        break;
+                }
+                return result;
+        }       
+};
+ 
+#endif /* PSP_PIXEL_FORMAT_H */ 

backends/platform/psp/pspkeyboard.h

@@ -28 +28 @@
 
 #include "common/events.h"
 #include "common/stream.h"
+#include "backends/platform/psp/display_client.h"
 #include <pspctrl.h>
 
 //number of modes
 #define MODE_COUNT 4
 #define guiStringsSize 8 /* size of guistrings array */
 
-class PSPKeyboard {
+class PSPKeyboard : public DisplayClient {
 
 private:
         enum State {
@@ -49 +50 @@
 public:
         PSPKeyboard();
         ~PSPKeyboard();
+        
         bool load();                                                                                            // Load keyboard into memory
         bool isInit() { return _init; }                                                         // Check for initialization
         bool isDirty() { return _dirty; }                                                       // Check if needs redrawing
+        void setDirty() { _dirty = true; }
+        void setClean() { _dirty = false; }
         bool isVisible() { return _state != kInvisible; }                       // Check if visible
-        bool processInput(Common::Event &event, SceCtrlData &pad, bool &usedInput);     // Process input
+        void setVisible(bool val);
+        bool processInput(Common::Event &event, SceCtrlData &pad);      // Process input
         void moveTo(const int newX, const int newY);                            // Move keyboard
         void render();                                                                                          // Draw the keyboard onscreen
 
 private:
-        struct gu_surface {
-                u32             surface_width;
-                u32             surface_height;
-                u32             texture_width;
-                u32             texture_height;
-                u8              *texture;
-                u32             *palette;
-                u32             paletteSize;
+        enum CursorDirections {
+                kUp = 0,
+                kRight,
+                kDown,
+                kLeft,
+                kCenter
         };
 
+        Buffer _buffers[guiStringsSize];
+        Palette _palettes[guiStringsSize];
+        GuRenderer _renderer;
 
-// structures used for drawing the keyboard
-        struct Vertex {
-                float u, v;
-                unsigned int color;
-                float x,y,z;
-        };
-
-        void surface_draw_offset(struct gu_surface* surface,
-                                int screenX, int screenY, int offsetX, int offsetY, int intWidth, int intHeight);
-        void block_copy(gu_surface* surface, u8 *texture);
-        int load_png_image(Common::SeekableReadStream *, unsigned char *ImageBuffer, uint32 *palette);
-        int get_png_image_size(Common::SeekableReadStream *, uint32 *png_width, uint32 *png_height, u32 *paletteSize);
+        int loadPngImage(Common::SeekableReadStream *file, Buffer &buffer, Palette &palette);
+        int getPngImageSize(Common::SeekableReadStream *, uint32 *png_width, uint32 *png_height, u32 *paletteSize);
         uint32 convert_pow2(uint32 size);
-        void flipNibbles(gu_surface* surface);          // Convert to PSP 4-bit format
         void increaseKeyboardLocationX(int amount);             // Move keyboard onscreen
         void increaseKeyboardLocationY(int amount);
+        void convertCursorToXY(CursorDirections cur, int &x, int &y);
 
+        void handleMoveState(SceCtrlData &pad);
+        bool handleDefaultState(Common::Event &event, SceCtrlData &pad);
+        bool handleCornersSelectedState(Common::Event &event, SceCtrlData &pad);
+        bool getInputChoice(Common::Event &event, SceCtrlData &pad);
+        void getCursorMovement(SceCtrlData &pad);
+        void handleRTriggerDownState(SceCtrlData &pad);
+        void handleLTriggerDownState(SceCtrlData &pad);
+        
         static short _modeChar[MODE_COUNT][5][6];
         static const char *_guiStrings[];
         bool _init;
-        unsigned int _prevButtons;      // A bit pattern.
+        uint32 _prevButtons;    // A bit pattern.
+        uint32 _buttonsChanged;
+        
         bool _dirty;                    // keyboard needs redrawing
         int _mode;                      // charset selected. (0 - letters or 1 - numbers)
-        int _moved_x;                           // location we've moved the KB to onscreen
-        int _moved_y;
+        int _movedX;                            // location we've moved the KB to onscreen
+        int _movedY;
         bool _moved;                            // whether the keyboard was moved
-        gu_surface      _keyTextures[guiStringsSize];
-
+        
         State _state;                           // State of keyboard Keyboard state machine
         State _lastState;
 
-        enum Cursor {
-                kUp = 0,
-                kRight,
-                kDown,
-                kLeft,
-                kCenter
-        };
+        CursorDirections _oldCursor;                    // Point to place of last cursor
 
-        Cursor _oldCursor;                      // Point to place of last cursor
-
 };
 
-#endif /* PSPKEYBOARD_H */
- No newline at end of file
+#endif /* PSPKEYBOARD_H */

backends/platform/psp/portdefs.h

@@ -50 +50 @@
 //#define printf  pspDebugScreenPrintf
 
 #endif /* PORTDEFS_H */
-
-

backends/platform/psp/powerman.h

@@ -118 +118 @@
                 kDoneSignallingSuspendedThreadsResume,
                 kDoneResume
         };
-#ifdef __PSP_DEBUG_SUSPEND__
 
         volatile int _listCounter;                                              /* How many people are in the list - just for debugging */
 
@@ -129 +128 @@
  public:
         int getPMStatus() { return _PMStatus; }
 
-#endif /* __PSP_DEBUG_SUSPEND__ */
-
  };
 
  // For easy access
 #define PowerMan        PowerManager::instance()
 
- #endif /* POWERMAN_H */
+#endif /* POWERMAN_H */

backends/fs/psp/psp-stream.h

@@ -49 +49 @@
         int _errorSuspend;
         mutable int _errorSource;
 
-#ifdef __PSP_DEBUG_SUSPEND__
+        // Error checking
         int _errorPos;
         void * _errorHandle;
         int _suspendCount;
-#endif /* __PSP_DEBUG_SUSPEND__ */
 
 public:
+        
+        const char *getObjectName() const { return "PSPIoStream"; }
         /**
          * Given a path, invoke fopen on that path and wrap the result in a
          * PSPIoStream instance.

backends/fs/psp/psp-fs-factory.h

@@ -35 +35 @@
  */
 class PSPFilesystemFactory : public FilesystemFactory, public Common::Singleton<PSPFilesystemFactory> {
 public:
+        const char *getObjectName() const { return "PSPFilesystemFactory"; }
         virtual AbstractFSNode *makeRootFileNode() const;
         virtual AbstractFSNode *makeCurrentDirectoryFileNode() const;
         virtual AbstractFSNode *makeFileNodePath(const Common::String &path) const;

backends/fs/psp/psp-fs.cpp

@@ -35 +35 @@
 
 #define ROOT_PATH       "ms0:/"
 
+//#define __PSP_PRINT_TO_FILE__
+//#define __PSP_DEBUG_FUNCS__ /* For debugging function calls */
+//#define __PSP_DEBUG_PRINT__   /* For debug printouts */
 #include "backends/platform/psp/trace.h"
 
 /**
@@ -63 +66 @@
          */
         PSPFilesystemNode(const Common::String &p, bool verify = true);
 
+        const char *getObjectName() const { return "PSPFileSystemNode"; }
         virtual bool exists() const;
         virtual Common::String getDisplayName() const { return _displayName; }
         virtual Common::String getName() const { return _displayName; }
@@ -87 +91 @@
 }
 
 PSPFilesystemNode::PSPFilesystemNode(const Common::String &p, bool verify) {
+        DEBUG_ENTER_FUNC();
         assert(p.size() > 0);
 
         _path = p;
@@ -94 +99 @@
         _isValid = true;
         _isDirectory = true;
 
+        PSP_DEBUG_PRINT_FUNC("path [%s]\n", _path.c_str());
+        
         if (verify) {
                 struct stat st;
                 if (PowerMan.beginCriticalSection()==PowerManager::Blocked)
-                        PSPDebugSuspend("Suspended in PSPFilesystemNode::PSPFilesystemNode\n");
+                        PSP_DEBUG_PRINT_FUNC("Suspended\n");
                 _isValid = (0 == stat(_path.c_str(), &st));
                 PowerMan.endCriticalSection();
                 _isDirectory = S_ISDIR(st.st_mode);
         }
+        DEBUG_EXIT_FUNC();
 }
 
 bool PSPFilesystemNode::exists() const {
+        DEBUG_ENTER_FUNC();
         int ret = 0;
 
         if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
-                PSPDebugSuspend("Suspended in PSPFilesystemNode::exists()\n");  // Make sure to block in case of suspend
+                PSP_DEBUG_PRINT_FUNC("Suspended\n");    // Make sure to block in case of suspend
 
+        PSP_DEBUG_PRINT_FUNC("path [%s]\n", _path.c_str());
+                
         ret = access(_path.c_str(), F_OK);
         PowerMan.endCriticalSection();
 
-        return ret == 0;
+        DEBUG_EXIT_FUNC();
+        return (ret == 0);
 }
 
 bool PSPFilesystemNode::isReadable() const {
+        DEBUG_ENTER_FUNC();
         int ret = 0;
 
         if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
-                        PSPDebugSuspend("Suspended in PSPFilesystemNode::isReadable()\n");      // Make sure to block in case of suspend
+                PSP_DEBUG_PRINT_FUNC("Suspended\n");    // Make sure to block in case of suspend
 
+        PSP_DEBUG_PRINT_FUNC("path [%s]\n", _path.c_str());     
+                
         ret = access(_path.c_str(), R_OK);
         PowerMan.endCriticalSection();
 
-        return ret == 0;
+        DEBUG_EXIT_FUNC();
+        return (ret == 0);
 }
 
 bool PSPFilesystemNode::isWritable() const {
+        DEBUG_ENTER_FUNC();
         int ret = 0;
 
         if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
-                PSPDebugSuspend("Suspended in PSPFilesystemNode::isWritable()\n");      // Make sure to block in case of suspend
+                PSP_DEBUG_PRINT_FUNC("Suspended\n");    // Make sure to block in case of suspend
 
+        PSP_DEBUG_PRINT_FUNC("path [%s]\n", _path.c_str());
+                
         ret = access(_path.c_str(), W_OK);
         PowerMan.endCriticalSection();
 
+        DEBUG_EXIT_FUNC();
         return ret == 0;
 }
 
 
 AbstractFSNode *PSPFilesystemNode::getChild(const Common::String &n) const {
+        DEBUG_ENTER_FUNC();
         // FIXME: Pretty lame implementation! We do no error checking to speak
         // of, do not check if this is a special node, etc.
         assert(_isDirectory);
@@ -151 +172 @@
                 newPath += '/';
         newPath += n;
 
-        return new PSPFilesystemNode(newPath, true);
+        PSP_DEBUG_PRINT_FUNC("child [%s]\n", newPath.c_str());
+        
+        AbstractFSNode *node = new PSPFilesystemNode(newPath, true);
+        
+        DEBUG_EXIT_FUNC();
+        return node;
 }
 
 bool PSPFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool hidden) const {
+        DEBUG_ENTER_FUNC();
         assert(_isDirectory);
 
         //TODO: honor the hidden flag
@@ -162 +189 @@
         bool ret = true;
 
         if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
-                PSPDebugSuspend("Suspended in PSPFilesystemNode::getChildren\n");       // Make sure to block in case of suspend
+                PSP_DEBUG_PRINT_FUNC("Suspended\n");    // Make sure to block in case of suspend
 
+        PSP_DEBUG_PRINT_FUNC("Current path[%s]\n", _path.c_str());      
+                
         int dfd  = sceIoDopen(_path.c_str());
         if (dfd > 0) {
                 SceIoDirent dir;
@@ -186 +215 @@
 
                         entry._path = newPath;
                         entry._isDirectory = dir.d_stat.st_attr & FIO_SO_IFDIR;
-
+                        
+                        PSP_DEBUG_PRINT_FUNC("Child[%s], %s\n", entry._path.c_str(), entry._isDirectory ? "dir" : "file");      
+                        
                         // Honor the chosen mode
                         if ((mode == Common::FSNode::kListFilesOnly && entry._isDirectory) ||
                            (mode == Common::FSNode::kListDirectoriesOnly && !entry._isDirectory))
@@ -202 +233 @@
         }
 
         PowerMan.endCriticalSection();
+        
+        DEBUG_EXIT_FUNC();
         return ret;
 }
 
 AbstractFSNode *PSPFilesystemNode::getParent() const {
+        DEBUG_ENTER_FUNC();
         if (_path == ROOT_PATH)
                 return 0;
 
+        PSP_DEBUG_PRINT_FUNC("current[%s]\n", _path.c_str());   
+                
         const char *start = _path.c_str();
         const char *end = lastPathComponent(_path, '/');
 
-        return new PSPFilesystemNode(Common::String(start, end - start), false);
+        AbstractFSNode *node = new PSPFilesystemNode(Common::String(start, end - start), false);
+        DEBUG_EXIT_FUNC();
+        return node;
 }
 
 Common::SeekableReadStream *PSPFilesystemNode::createReadStream() {

backends/fs/psp/psp-stream.cpp

@@ -27 +27 @@
 #include <SDL/SDL_thread.h>
 #include <SDL/SDL_mutex.h>
 
-#include "backends/platform/psp/trace.h"
 #include "backends/platform/psp/powerman.h"
 #include "backends/fs/psp/psp-stream.h"
 
 #include <errno.h>
 
+//#define __PSP_PRINT_TO_FILE__
+//#define __PSP_DEBUG_FUNCS__ /* For debugging function calls */
+//#define __PSP_DEBUG_PRINT__   /* For debug printouts */
+#include "backends/platform/psp/trace.h"
+
 PSPIoStream::PSPIoStream(const Common::String &path, bool writeMode)
 : StdioStream((void *)1), _path(path), _writeMode(writeMode) {
-
+        DEBUG_ENTER_FUNC();
+        
         assert(!path.empty());
 
         _handle = (void *)0;            // Need to do this since base class asserts not 0.
@@ -43 +48 @@
         _feof = false;
         _pos = 0;
 
-#ifdef __PSP_DEBUG_SUSPEND__
+        /* for error checking */
         _errorSuspend = 0;
         _errorSource = 0;
         _errorPos = 0;
         _errorHandle = 0;
         _suspendCount = 0;
-#endif
+        
+        DEBUG_EXIT_FUNC();
 }
 
 PSPIoStream::~PSPIoStream() {
+        DEBUG_ENTER_FUNC();
+        
         if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
-                PSPDebugSuspend("Suspended in PSPIoStream::~PSPIoStream()\n");
+                PSP_DEBUG_PRINT_FUNC("Suspended\n");
 
         PowerMan.unregisterSuspend(this); // Unregister with powermanager to be suspended
-                                                                 // Must do this before fclose() or resume() will reopen.
+                                                                          // Must do this before fclose() or resume() will reopen.
 
         fclose((FILE *)_handle);        // We don't need a critical section(?). Worst case, the handle gets closed on its own
 
         PowerMan.endCriticalSection();
+        
+        DEBUG_EXIT_FUNC();
 }
 
-// Function to open the file pointed to by the path.
-//
-//
+/* Function to open the file pointed to by the path.
+ *
+ */
 void *PSPIoStream::open() {
+        DEBUG_ENTER_FUNC();
         if (PowerMan.beginCriticalSection() == PowerManager::Blocked) {
                 // No need to open. Just return the _handle resume() already opened.
-                PSPDebugSuspend("Suspended in PSPIoStream::open\n");
+                PSP_DEBUG_PRINT_FUNC("Suspended\n");
         }
 
         _handle = fopen(_path.c_str(), _writeMode ? "wb" : "rb");       // open
@@ -79 +90 @@
 
         PowerMan.endCriticalSection();
 
+        DEBUG_EXIT_FUNC();
         return _handle;
 }
 
 bool PSPIoStream::err() const {
+        DEBUG_ENTER_FUNC();
         if (_ferror)
-                PSPDebugSuspend("In PSPIoStream::err - mem_ferror=%d, source=%d, suspend error=%d, pos=%d, _errorPos=%d, _errorHandle=%p, suspendCount=%d _handle\n",
+                PSP_ERROR("mem_ferror[%d], source[%d], suspend error[%d], pos[%d], _errorPos[%d], _errorHandle[%p], suspendCount[%d]\n",
                         _ferror, _errorSource, _errorSuspend, _pos, _errorPos, _errorHandle, _suspendCount);
 
+        DEBUG_EXIT_FUNC();
         return _ferror;
 }
 
 void PSPIoStream::clearErr() {
         _ferror = false;        // Remove regular error bit
-
 }
 
 bool PSPIoStream::eos() const {
@@ -105 +118 @@
 
 
 int32 PSPIoStream::size() const {
+        DEBUG_ENTER_FUNC();
         if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
-                PSPDebugSuspend("Suspended in PSPIoStream::size()\n");
+                PSP_DEBUG_PRINT_FUNC("Suspended\n");
 
         fseek((FILE *)_handle, 0, SEEK_END);
         int32 length = ftell((FILE *)_handle);
         fseek((FILE *)_handle, _pos, SEEK_SET);
 
         if (_pos < 0 || length < 0) {   // Check for errors
-                PSPDebugSuspend("In PSPIoStream::size(). encountered an error!\n");
+                _errorSource = 2;
+                PSP_ERROR("pos[%d] or length[%d] < 0!\n", _pos, length);
                 _ferror = true;
                 length = -1;                            // If our oldPos is bad, we want length to be bad too to signal
                 clearerr((FILE *)_handle);
-
-#ifdef __PSP_DEBUG_SUSPEND__
-                _errorSource = 2;
-#endif
         }
 
         PowerMan.endCriticalSection();
 
+        DEBUG_EXIT_FUNC();
         return length;
 }
 
 bool PSPIoStream::seek(int32 offs, int whence) {
+        DEBUG_ENTER_FUNC();
+        
         // Check if we can access the file
         if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
-                PSPDebugSuspend("Suspended in PSPIoStream::seek()\n");
+                PSP_DEBUG_PRINT_FUNC("Suspended\n");
 
         int ret = fseek((FILE *)_handle, offs, whence);
 
         if (ret != 0) {
                 _ferror = true;
-                PSPDebugSuspend("In PSPIoStream::seek(). encountered an error!\n");
+                PSP_ERROR("fseek returned with [%d], non-zero\n", ret);
                 clearerr((FILE *)_handle);
                 _feof = feof((FILE *)_handle);
-
-#ifdef __PSP_DEBUG_SUSPEND__
                 _errorSource = 3;
-#endif
         }
         else {                                  // everything ok
                 _feof = false;          // Reset eof flag since we know it was ok
@@ -153 +164 @@
 
         PowerMan.endCriticalSection();
 
-        return ret == 0;
+        DEBUG_EXIT_FUNC();
+        return (ret == 0);
 }
 
 uint32 PSPIoStream::read(void *ptr, uint32 len) {
+        DEBUG_ENTER_FUNC();
         // Check if we can access the file
         if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
-                PSPDebugSuspend("Suspended in PSPIoStream::read()\n");
+                PSP_DEBUG_PRINT_FUNC("Suspended\n");
+                
+        PSP_DEBUG_PRINT_FUNC("filename[%s], len[%d]\n", _path.c_str(), len);
 
         size_t ret = fread((byte *)ptr, 1, len, (FILE *)_handle);
 
@@ -171 +186 @@
                         _ferror = true;
                         clearerr((FILE *)_handle);
                         _pos = ftell((FILE *)_handle);  // Update our position
-                        PSPDebugSuspend("In PSPIoStream::read(). encountered an error!\n");
-
-#ifdef __PSP_DEBUG_SUSPEND__
                         _errorSource = 4;
-#endif
+                        PSP_ERROR("fread returned ret[%d] instead of len[%d]\n", ret, len);
                 }
         }
 
         PowerMan.endCriticalSection();
 
+        DEBUG_EXIT_FUNC();
         return ret;
 }
 
 uint32 PSPIoStream::write(const void *ptr, uint32 len) {
+        DEBUG_ENTER_FUNC();
         // Check if we can access the file
         if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
-                PSPDebugSuspend("Suspended in PSPIoStream::read()\n");
+                PSP_DEBUG_PRINT_FUNC("Suspended\n");
 
+        PSP_DEBUG_PRINT_FUNC("filename[%s], len[%d]\n", _path.c_str(), len);    
+                
         size_t ret = fwrite(ptr, 1, len, (FILE *)_handle);
 
         _pos += ret;
@@ -197 +213 @@
                 _ferror = true;
                 clearerr((FILE *)_handle);
                 _pos = ftell((FILE *)_handle);  // Update pos
-                PSPDebugTrace("In PSPIoStream::write(). encountered an error!\n");
-
-#ifdef __PSP_DEBUG_SUSPEND__
                 _errorSource = 5;
-#endif
+                PSP_ERROR("fwrite returned[%d] instead of len[%d]\n", ret, len);
         }
 
         PowerMan.endCriticalSection();
 
+        DEBUG_EXIT_FUNC();
         return ret;
 }
 
 bool PSPIoStream::flush() {
+        DEBUG_ENTER_FUNC();
         // Enter critical section
         if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
-                PSPDebugSuspend("Suspended in PSPIoStream::read()\n");
+                PSP_DEBUG_PRINT_FUNC("Suspended\n");
 
         int ret = fflush((FILE *)_handle);
 
         if (ret != 0) {
                 _ferror = true;
                 clearerr((FILE *)_handle);
-                PSPDebugSuspend("In PSPIoStream::flush(). encountered an error!\n");
-
-#ifdef __PSP_DEBUG_SUSPEND__
                 _errorSource = 6;
-#endif
+                PSP_ERROR("fflush returned ret[%u]\n", ret);
         }
 
         PowerMan.endCriticalSection();
 
-        return ret == 0;
+        DEBUG_EXIT_FUNC();
+        return (ret == 0);
 }
 
 // For the PSP, since we're building in suspend support, we moved opening
 // the actual file to an open function since we need an actual PSPIoStream object to suspend.
 //
 PSPIoStream *PSPIoStream::makeFromPath(const Common::String &path, bool writeMode) {
+        DEBUG_ENTER_FUNC();
         PSPIoStream *stream = new PSPIoStream(path, writeMode);
 
-        if (stream->open() > 0) {
-                return stream;
-        } else {
+        if (stream->open() <= 0) {
                 delete stream;
-                return 0;
+                stream = 0;
         }
+        
+        DEBUG_EXIT_FUNC();
+        return stream;
 }
 
 /*
  *  Function to suspend the IO stream (called by PowerManager)
+ *  we can have no output here
  */
 int PSPIoStream::suspend() {
-#ifdef __PSP_DEBUG_SUSPEND__
+        DEBUG_ENTER_FUNC();
         _suspendCount++;
 
-        if (_handle > 0 && _pos < 0) {
+        if (_handle > 0 && _pos < 0) {  /* check for error */
                 _errorSuspend = SuspendError;
                 _errorPos = _pos;
                 _errorHandle = _handle;
         }
-#endif /* __PSP_DEBUG_SUSPEND__ */
 
         if (_handle > 0) {
                 fclose((FILE *)_handle);                // close our file descriptor
                 _handle = (void *)0xFFFFFFFF;   // Set handle to non-null invalid value so makeFromPath doesn't return error
         }
 
+        DEBUG_EXIT_FUNC();
         return 0;
 }
 
@@ -271 +287 @@
  *  Function to resume the IO stream (called by Power Manager)
  */
 int PSPIoStream::resume() {
+        DEBUG_ENTER_FUNC();
         int ret = 0;
-#ifdef __PSP_DEBUG_SUSPEND__
         _suspendCount--;
-#endif
 
         // We reopen our file descriptor
         _handle = fopen(_path.c_str(), _writeMode ? "wb" : "rb");
         if (_handle <= 0) {
-                PSPDebugSuspend("PSPIoStream::resume(): Couldn't reopen file %s\n", _path.c_str());
+                PSP_ERROR("Couldn't reopen file %s\n", _path.c_str());
         }
 
         // Resume our previous position
         if (_handle > 0 && _pos > 0) {
                 ret = fseek((FILE *)_handle, _pos, SEEK_SET);
 
-#ifdef __PSP_DEBUG_SUSPEND__
                 if (ret != 0) {         // Check for problem
                         _errorSuspend = ResumeError;
                         _errorPos = _pos;
                         _errorHandle = _handle;
                 }
-#endif
-
         }
-
+        DEBUG_EXIT_FUNC();
         return ret;
 }