PSP: Fix code formatting using astyle

svn-id: r48634

28 files changed, 839 insertions, 831 deletions

diff --git a/backends/fs/psp/psp-fs.cpp b/backends/fs/psp/psp-fs.cpp
index 0d824846e3..64983f7144 100644
--- a/backends/fs/psp/psp-fs.cpp
+++ b/backends/fs/psp/psp-fs.cpp
@@ -100,10 +100,10 @@ PSPFilesystemNode::PSPFilesystemNode(const Common::String &p, bool verify) {
 	_isDirectory = true;
 
 	PSP_DEBUG_PRINT_FUNC("path [%s]\n", _path.c_str());
-	
+
 	if (verify) {
 		struct stat st;
-		if (PowerMan.beginCriticalSection()==PowerManager::Blocked)
+		if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
 			PSP_DEBUG_PRINT_FUNC("Suspended\n");
 		_isValid = (0 == stat(_path.c_str(), &st));
 		PowerMan.endCriticalSection();
@@ -120,7 +120,7 @@ bool PSPFilesystemNode::exists() const {
 		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();
 
@@ -135,8 +135,8 @@ bool PSPFilesystemNode::isReadable() const {
 	if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
 		PSP_DEBUG_PRINT_FUNC("Suspended\n");	// Make sure to block in case of suspend
 
-	PSP_DEBUG_PRINT_FUNC("path [%s]\n", _path.c_str());	
-		
+	PSP_DEBUG_PRINT_FUNC("path [%s]\n", _path.c_str());
+
 	ret = access(_path.c_str(), R_OK);
 	PowerMan.endCriticalSection();
 
@@ -152,7 +152,7 @@ bool PSPFilesystemNode::isWritable() const {
 		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();
 
@@ -173,9 +173,9 @@ AbstractFSNode *PSPFilesystemNode::getChild(const Common::String &n) const {
 	newPath += n;
 
 	PSP_DEBUG_PRINT_FUNC("child [%s]\n", newPath.c_str());
-	
+
 	AbstractFSNode *node = new PSPFilesystemNode(newPath, true);
-	
+
 	DEBUG_EXIT_FUNC();
 	return node;
 }
@@ -191,8 +191,8 @@ bool PSPFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool
 	if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
 		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());	
-		
+	PSP_DEBUG_PRINT_FUNC("Current path[%s]\n", _path.c_str());
+
 	int dfd  = sceIoDopen(_path.c_str());
 	if (dfd > 0) {
 		SceIoDirent dir;
@@ -215,12 +215,12 @@ bool PSPFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool
 
 			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");	
-			
+
+			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))
+			        (mode == Common::FSNode::kListDirectoriesOnly && !entry._isDirectory))
 				continue;
 
 			myList.push_back(new PSPFilesystemNode(entry));
@@ -233,7 +233,7 @@ bool PSPFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool
 	}
 
 	PowerMan.endCriticalSection();
-	
+
 	DEBUG_EXIT_FUNC();
 	return ret;
 }
@@ -243,8 +243,8 @@ AbstractFSNode *PSPFilesystemNode::getParent() const {
 	if (_path == ROOT_PATH)
 		return 0;
 
-	PSP_DEBUG_PRINT_FUNC("current[%s]\n", _path.c_str());	
-		
+	PSP_DEBUG_PRINT_FUNC("current[%s]\n", _path.c_str());
+
 	const char *start = _path.c_str();
 	const char *end = lastPathComponent(_path, '/');
 
diff --git a/backends/fs/psp/psp-stream.cpp b/backends/fs/psp/psp-stream.cpp
index 5b955beee6..2b99554182 100644
--- a/backends/fs/psp/psp-stream.cpp
+++ b/backends/fs/psp/psp-stream.cpp
@@ -38,9 +38,9 @@
 #include "backends/platform/psp/trace.h"
 
 PSPIoStream::PSPIoStream(const Common::String &path, bool writeMode)
-: StdioStream((void *)1), _path(path), _writeMode(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.
@@ -54,23 +54,23 @@ PSPIoStream::PSPIoStream(const Common::String &path, bool writeMode)
 	_errorPos = 0;
 	_errorHandle = 0;
 	_suspendCount = 0;
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
 PSPIoStream::~PSPIoStream() {
 	DEBUG_ENTER_FUNC();
-	
+
 	if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
 		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();
 }
 
@@ -98,7 +98,7 @@ bool PSPIoStream::err() const {
 	DEBUG_ENTER_FUNC();
 	if (_ferror)
 		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);
+		          _ferror, _errorSource, _errorSuspend, _pos, _errorPos, _errorHandle, _suspendCount);
 
 	DEBUG_EXIT_FUNC();
 	return _ferror;
@@ -142,7 +142,7 @@ int32 PSPIoStream::size() const {
 
 bool PSPIoStream::seek(int32 offs, int whence) {
 	DEBUG_ENTER_FUNC();
-	
+
 	// Check if we can access the file
 	if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
 		PSP_DEBUG_PRINT_FUNC("Suspended\n");
@@ -155,8 +155,7 @@ bool PSPIoStream::seek(int32 offs, int whence) {
 		clearerr((FILE *)_handle);
 		_feof = feof((FILE *)_handle);
 		_errorSource = 3;
-	}
-	else {					// everything ok
+	} else {					// everything ok
 		_feof = false;		// Reset eof flag since we know it was ok
 	}
 
@@ -173,7 +172,7 @@ uint32 PSPIoStream::read(void *ptr, uint32 len) {
 	// Check if we can access the file
 	if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
 		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);
@@ -203,8 +202,8 @@ uint32 PSPIoStream::write(const void *ptr, uint32 len) {
 	if (PowerMan.beginCriticalSection() == PowerManager::Blocked)
 		PSP_DEBUG_PRINT_FUNC("Suspended\n");
 
-	PSP_DEBUG_PRINT_FUNC("filename[%s], len[%d]\n", _path.c_str(), len);	
-		
+	PSP_DEBUG_PRINT_FUNC("filename[%s], len[%d]\n", _path.c_str(), len);
+
 	size_t ret = fwrite(ptr, 1, len, (FILE *)_handle);
 
 	_pos += ret;
@@ -255,7 +254,7 @@ PSPIoStream *PSPIoStream::makeFromPath(const Common::String &path, bool writeMod
 		delete stream;
 		stream = 0;
 	}
-	
+
 	DEBUG_EXIT_FUNC();
 	return stream;
 }
diff --git a/backends/fs/psp/psp-stream.h b/backends/fs/psp/psp-stream.h
index 20836ddf32..9fcdd6d606 100644
--- a/backends/fs/psp/psp-stream.h
+++ b/backends/fs/psp/psp-stream.h
@@ -55,7 +55,7 @@ protected:
 	int _suspendCount;
 
 public:
-	
+
 	const char *getObjectName() const { return "PSPIoStream"; }
 	/**
 	 * Given a path, invoke fopen on that path and wrap the result in a
diff --git a/backends/platform/psp/cursor.cpp b/backends/platform/psp/cursor.cpp
index b6b9a70458..8d1f6fec86 100644
--- a/backends/platform/psp/cursor.cpp
+++ b/backends/platform/psp/cursor.cpp
@@ -29,33 +29,33 @@
 #include "backends/platform/psp/cursor.h"
 
 //#define __PSP_DEBUG_FUNCS__	/* For debugging the stack */
-//#define __PSP_DEBUG_PRINT__ 
+//#define __PSP_DEBUG_PRINT__
+
+#include "backends/platform/psp/trace.h"
 
-#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();
 }
 
@@ -65,17 +65,17 @@ void Cursor::setCursorPalette(const byte *colors, uint start, uint num) {
 	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();
@@ -83,17 +83,17 @@ void Cursor::setScreenPalette(const byte *colors, uint start, uint num) {
 	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())
@@ -103,7 +103,7 @@ void Cursor::setKeyColor(uint32 color) {
 	}
 	// Don't need anything special for 16-bit
 	_keyColor = color;
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -114,29 +114,29 @@ void Cursor::clearKeyColor() {
 	// 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	
+			_screenPalette.setColorPositionAlpha(_keyColor, false);		// set keycolor to 0
 		if (_palette.isAllocated())
-			_palette.setColorPositionAlpha(_keyColor, false);	
+			_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();		
+	DEBUG_EXIT_FUNC();
 }
 
 inline void Cursor::setSize(uint32 width, uint32 height) {
@@ -145,21 +145,21 @@ inline void Cursor::setSize(uint32 width, uint32 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	
+
+	// debug
 	//PSP_DEBUG_DO(_buffer.print(0xF));
 
 	DEBUG_EXIT_FUNC();
@@ -179,16 +179,16 @@ void Cursor::setHotspot(int32 x, int32 y) {
 
 // Returns true if change in x or y
 bool Cursor::increaseXY(int32 incX, int32 incY) {
-	DEBUG_ENTER_FUNC();	
+	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;
@@ -198,62 +198,62 @@ bool Cursor::increaseXY(int32 incX, int32 incY) {
 		_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
+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; 
-	
+	_mouseLimitWidth = width;
+	_mouseLimitHeight = height;
+
 	DEBUG_EXIT_FUNC();
 }
-	
-// Adjust X,Y movement for the screen size to keep it consistent	
+
+// 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; 
+		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))) {	
+
+	// Make sure we didn't destroy minimum movement
+	if (!((x && !newX) || (y && !newY))) {
 		x = newX;
 		y = newY;
 	}
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -264,55 +264,55 @@ void Cursor::setScreenPaletteScummvmPixelFormat(const Graphics::PixelFormat *for
 	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);		
+		_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()) 
+
+	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();
@@ -320,29 +320,29 @@ void Cursor::setSizeAndScummvmPixelFormat(uint32 width, uint32 height, const Gra
 	}
 
 	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);		
+		_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; 
+	DEBUG_ENTER_FUNC();
+
+	_x = x;
+	_y = y;
 	updateRendererOffset();	// Very important to let renderer know things changed
 	setDirty();
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
diff --git a/backends/platform/psp/cursor.h b/backends/platform/psp/cursor.h
index 49f58cd3f9..d68859e9ad 100644
--- a/backends/platform/psp/cursor.h
+++ b/backends/platform/psp/cursor.h
@@ -22,7 +22,7 @@
  * $Id: osys_psp.h 46120 2009-11-24 10:33:30Z Bluddy $
  *
  */
- 
+
 #ifndef MOUSE_H
 #define MOUSE_H
 
@@ -37,16 +37,16 @@ private:
 	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) { }
+	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 setKeyColor(uint32 color);
 	void setCursorTargetScale(int scale) { _cursorTargetScale = scale; }
 	void setScreenPalette(const byte *colors, uint start, uint num);
 	void copyFromArray(const byte *array);
@@ -54,7 +54,7 @@ public:
 	Buffer &buffer() { return _buffer; }
 	void setCursorPalette(const byte *colors, uint start, uint num);
 	void enableCursorPalette(bool enable);
-	void setLimits(uint32 width, uint32 height); 
+	void setLimits(uint32 width, uint32 height);
 	void setXY(int x, int y);
 	int32 getX() { return _x; }
 	int32 getY() { return _y; }
@@ -68,14 +68,14 @@ public:
 	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);													
+	        PSPPixelFormat::Type &bufferFormat,
+	        PSPPixelFormat::Type &paletteFormat,
+	        uint32 &numOfEntries);
+	void setRendererModePalettized(bool palettized);
 };
 
 #endif /* MOUSE_H */
diff --git a/backends/platform/psp/default_display_client.cpp b/backends/platform/psp/default_display_client.cpp
index eb20980315..7f2529483c 100644
--- a/backends/platform/psp/default_display_client.cpp
+++ b/backends/platform/psp/default_display_client.cpp
@@ -36,15 +36,14 @@
 
 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;
-		}
+		PSP_ERROR("Couldn't allocate buffer.\n");
+		DEBUG_EXIT_FUNC();
+		return false;
+	}
 
-	if (_buffer.hasPalette())
-	{
+	if (_buffer.hasPalette()) {
 		PSP_DEBUG_PRINT("_palette[%p]\n", &_palette);
 
 		if (!_palette.allocate()) {
@@ -53,7 +52,7 @@ bool DefaultDisplayClient::allocate(bool bufferInVram /* = false */, bool palett
 			return false;
 		}
 	}
-	
+
 	DEBUG_EXIT_FUNC();
 	return true;
 }
@@ -88,12 +87,12 @@ void DefaultDisplayClient::init() {
 
 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); 
+	_buffer.copyFromRect(buf, pitch, destX, destY, recWidth, recHeight);
 	setDirty();
 	DEBUG_EXIT_FUNC();
 }
 
-void DefaultDisplayClient::copyToArray(byte *dst, int pitch) { 
+void DefaultDisplayClient::copyToArray(byte *dst, int pitch) {
 	DEBUG_ENTER_FUNC();
 	_buffer.copyToArray(dst, pitch);
 	DEBUG_EXIT_FUNC();
@@ -115,7 +114,7 @@ void Overlay::init() {
 
 void Overlay::setBytesPerPixel(uint32 size) {
 	DEBUG_ENTER_FUNC();
-	
+
 	switch (size) {
 	case 1:
 		_buffer.setPixelFormat(PSPPixelFormat::Type_Palette_8bit);
@@ -128,7 +127,7 @@ void Overlay::setBytesPerPixel(uint32 size) {
 		_buffer.setPixelFormat(PSPPixelFormat::Type_8888);
 		break;
 	}
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -147,7 +146,7 @@ void Overlay::copyToArray(OverlayColor *buf, int pitch) {
 
 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);
@@ -157,9 +156,9 @@ void Overlay::copyFromRect(const OverlayColor *buf, int pitch, int x, int y, int
 
 bool Overlay::allocate() {
 	DEBUG_ENTER_FUNC();
-	
+
 	bool ret = DefaultDisplayClient::allocate(true, false);	// buffer in VRAM
-	
+
 	DEBUG_EXIT_FUNC();
 	return ret;
 }
@@ -179,7 +178,7 @@ void Screen::init() {
 }
 
 void Screen::setShakePos(int pos) {
-	_shakePos = pos; 
+	_shakePos = pos;
 	_renderer.setOffsetOnScreen(0, pos);
 	setDirty();
 }
@@ -189,7 +188,7 @@ void Screen::setSize(uint32 width, uint32 height) {
 
 	_buffer.setSize(width, height, Buffer::kSizeBySourceSize);
 	_renderer.setDrawWholeBuffer();	// We need to let the renderer know how much to draw
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -203,36 +202,36 @@ void Screen::setScummvmPixelFormat(const Graphics::PixelFormat *format) {
 	} 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();
 }
diff --git a/backends/platform/psp/default_display_client.h b/backends/platform/psp/default_display_client.h
index e83b0bf04d..9fea1a3027 100644
--- a/backends/platform/psp/default_display_client.h
+++ b/backends/platform/psp/default_display_client.h
@@ -24,7 +24,7 @@
  */
 
 #ifndef PSP_DEF_DISPLAY_CLIENT_H
-#define PSP_DEF_DISPLAY_CLIENT_H 
+#define PSP_DEF_DISPLAY_CLIENT_H
 
 /**
  *	Default display client that is useful for most purposes.
@@ -32,7 +32,7 @@
 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; }
@@ -46,8 +46,8 @@ public:
 	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 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);
@@ -70,13 +70,13 @@ 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);	
+	void copyFromRect(const OverlayColor *buf, int pitch, int x, int y, int w, int h);
 };
 
 /**
@@ -89,16 +89,16 @@ public:
 		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);	
-	
+	void unlock() { setDirty(); } // set dirty here because of changes
+	void setSize(uint32 width, uint32 height);
+
 private:
 	uint32 _shakePos;
 	Graphics::PixelFormat _pixelFormat;
diff --git a/backends/platform/psp/display_client.cpp b/backends/platform/psp/display_client.cpp
index 73a3fefe5b..44998e4969 100644
--- a/backends/platform/psp/display_client.cpp
+++ b/backends/platform/psp/display_client.cpp
@@ -27,7 +27,7 @@
 #include <pspdisplay.h>
 #include <psputils.h>
 
-#include "common/scummsys.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"
@@ -51,9 +51,9 @@ void Palette::clear() {
 
 	if (_values && _numOfEntries)
 		memset(_values, 0, getSizeInBytes());
-		
+
 	PSP_DEBUG_PRINT("_values[%p]\n", _values);
-		
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -61,33 +61,33 @@ void Palette::clear() {
 //
 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);
+	                _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 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;
+		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();
 }
 
@@ -98,43 +98,42 @@ void Palette::setPartial(const byte *colors, uint32 start, uint32 num, bool supp
 
 	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;	
+			src += 4;
 			palette++;
 		}
-	}
-	else if (_pixelFormat.bitsPerPixel == 32) {
+	} 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;	
+			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) 
+
+	if (paletteType == PSPPixelFormat::Type_Unknown)
 		PSP_ERROR("Unknown paletteType[%u]\n", paletteType);
 
 	switch (bufferType) {
@@ -152,9 +151,9 @@ void Palette::setPixelFormats(PSPPixelFormat::Type paletteType, PSPPixelFormat::
 		_numOfEntries = 0;
 		break;
 	}
-	
+
 	_pixelFormat.set(paletteType, swapRedBlue);
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -164,40 +163,40 @@ bool Palette::allocate() {
 	PSP_DEBUG_PRINT("_pixelFormat: format[%u], bpp[%u]\n", _pixelFormat.format, _pixelFormat.bitsPerPixel);
 
 	if (_values) {
-		free (CACHED(_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) 
+	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));
+
+	free(CACHED(_values));
 	_values = 0;
 	_numOfEntries = 0;
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -208,32 +207,32 @@ void Palette::getPartial(byte *colors, uint start, uint num) {
 
 	assert(_values);
 	assert(_numOfEntries);
-	
+
 	uint32 r, g, b, a;
 
 	if (start + num > _numOfEntries)	// Check boundary
 		num = _numOfEntries - start;
-	
-	if (_pixelFormat.bitsPerPixel == 16) {	
+
+	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) {	
+	} 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;
@@ -241,26 +240,26 @@ void Palette::getPartial(byte *colors, uint start, uint num) {
 			palette++;
 		}
 	}
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
-void Palette::setSingleColorRGBA(uint32 num, byte r, byte g, byte b, byte a) {	
+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);
-	
+
+	assert(_values);
+	assert(num < _numOfEntries);
+
 	switch (_pixelFormat.bitsPerPixel) {
-	case 16: 
+	case 16:
 		shortValues = (uint16 *)_values;
 		shortValues[num] = _pixelFormat.rgbaToColor(r, g, b, a);
 		break;
-	case 32: 
+	case 32:
 		wordValues = (uint32 *)_values;
-		wordValues[num] = _pixelFormat.rgbaToColor(r, g, b, a);		
+		wordValues[num] = _pixelFormat.rgbaToColor(r, g, b, a);
 		break;
 	default:
 		PSP_ERROR("Incorrect bitsPerPixel[%d]\n", _pixelFormat.bitsPerPixel);
@@ -272,20 +271,20 @@ void Palette::setSingleColorRGBA(uint32 num, byte r, byte g, byte b, byte a) {
 // Print to screen
 void Palette::print(uint32 numToPrint /* = 0 */) {
 	if (_numOfEntries > 0) {
-		assert (_values);
-		
-		if (numToPrint > _numOfEntries || numToPrint == 0) 
+		assert(_values);
+
+		if (numToPrint > _numOfEntries || numToPrint == 0)
 			numToPrint = _numOfEntries;
-		
+
 		PSP_INFO_PRINT("cursor palette:\n");
-		
-		for (unsigned int i=0; i<numToPrint; i++) {
+
+		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");
 	}
 }
@@ -305,17 +304,17 @@ uint32 Palette::getRGBAColorAt(uint32 position) {
 
 // class Buffer ---------------------------------------------------
 
-void Buffer::setPixelFormat(PSPPixelFormat::Type type, bool swapRedBlue) { 
+void Buffer::setPixelFormat(PSPPixelFormat::Type type, bool swapRedBlue) {
 	if (type == PSPPixelFormat::Type_None ||
-		type == PSPPixelFormat::Type_Unknown)
+	        type == PSPPixelFormat::Type_Unknown)
 		PSP_ERROR("Unhandled buffer format[%u]\n", type);
-		
-	_pixelFormat.set(type, swapRedBlue); 
+
+	_pixelFormat.set(type, swapRedBlue);
 }
 
 bool Buffer::hasPalette() {
 	if (_pixelFormat.format == PSPPixelFormat::Type_Palette_8bit ||
-		_pixelFormat.format == PSPPixelFormat::Type_Palette_4bit)
+	        _pixelFormat.format == PSPPixelFormat::Type_Palette_4bit)
 		return true;
 
 	return false;
@@ -324,10 +323,10 @@ bool Buffer::hasPalette() {
 /* 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();
 }
 
@@ -335,8 +334,8 @@ void Buffer::copyFromArray(const byte *buffer, int pitch) {
 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);
-	
+	assert(_pixels);
+
 	if (recWidth > _sourceSize.width - destX) {
 		recWidth = _sourceSize.width - destX;
 	}
@@ -351,7 +350,7 @@ void Buffer::copyFromRect(const byte *buf, uint32 pitch, int destX, int destY, u
 	}
 
 	byte *dst = _pixels + _pixelFormat.pixelsToBytes((destY * _width) + destX);
-	
+
 	uint32 recWidthInBytes = _pixelFormat.pixelsToBytes(recWidth);
 	uint32 realWidthInBytes = _pixelFormat.pixelsToBytes(_width);
 
@@ -366,15 +365,15 @@ void Buffer::copyFromRect(const byte *buf, uint32 pitch, int destX, int destY, u
 			dst += realWidthInBytes;
 		} while (--recHeight);
 	}
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
 /* pitch is in bytes */
 void Buffer::copyToArray(byte *dst, int pitch) {
 	DEBUG_ENTER_FUNC();
-	assert (_pixels);
-	
+	assert(_pixels);
+
 	uint32 h = _height;
 	byte *src = _pixels;
 	uint32 sourceWidthInBytes = _pixelFormat.pixelsToBytes(_sourceSize.width);
@@ -386,7 +385,7 @@ void Buffer::copyToArray(byte *dst, int pitch) {
 		src += realWidthInBytes;
 		dst += pitch;
 	} while (--h);
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -395,7 +394,7 @@ void Buffer::copyToArray(byte *dst, int pitch) {
 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;
 
@@ -405,18 +404,17 @@ void Buffer::setSize(uint32 width, uint32 height, HowToSize textureOrSource/*=kS
 	if (textureOrSource == kSizeByTextureSize) {
 		_width = _textureSize.width;
 		_height = _textureSize.height;
-	}
-	else { /* kSizeBySourceSize */
+	} 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;
@@ -430,7 +428,7 @@ uint32 Buffer::scaleUpToPowerOfTwo(uint32 size) {
 		textureDimension = 256;
 	else
 		textureDimension = 512;
-	
+
 	PSP_DEBUG_PRINT("power of 2 = %u\n", textureDimension);
 
 	return textureDimension;
@@ -438,7 +436,7 @@ uint32 Buffer::scaleUpToPowerOfTwo(uint32 size) {
 
 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);
 
@@ -446,17 +444,17 @@ bool Buffer::allocate(bool inVram/*=false*/) {
 		if (VramAllocator::isAddressInVram(_pixels)) 	// Check if in VRAM
 			VramAllocator::instance().deallocate(_pixels);
 		else	// not in VRAM
-			free (CACHED(_pixels));
-			
-		_pixels = 0;	
+			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);
@@ -467,7 +465,7 @@ bool Buffer::allocate(bool inVram/*=false*/) {
 		DEBUG_EXIT_FUNC();
 		return false;
 	}
-	
+
 	// Use uncached memory
 	GuRenderer::cacheInvalidate(_pixels, size);
 	_pixels = UNCACHED(_pixels);
@@ -482,35 +480,35 @@ void Buffer::deallocate() {
 
 	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) 
+
+	if (_pixelFormat.bitsPerPixel != 4)
 		return;
-		
-	assert(_pixels);	
-	
+
+	assert(_pixels);
+
 	uint32 *dest = (uint32 *)_pixels;
 
 	for (uint32 i = 0; i < getSourceHeight(); i++) {
@@ -526,24 +524,24 @@ void Buffer::flipNibbles() {
 // 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++) {
+
+	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");
@@ -563,16 +561,16 @@ void GuRenderer::render() {
 	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();	
+
+	Vertex *vertices = guGetVertices();
 	fillVertices(vertices);
 
 	guDrawVertices(vertices);
@@ -581,17 +579,17 @@ void GuRenderer::render() {
 		setMaxTextureOffsetByIndex(1, 0);
 
 		guLoadTexture();
-		
+
 		vertices = guGetVertices();
 		fillVertices(vertices);
 
 		guDrawVertices(vertices);
 	}
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
-inline void GuRenderer::setMaxTextureOffsetByIndex(uint32 x, uint32 y) { 
+inline void GuRenderer::setMaxTextureOffsetByIndex(uint32 x, uint32 y) {
 	DEBUG_ENTER_FUNC();
 	const uint32 maxTextureSizeShift = 9; /* corresponds to 512 = max texture size*/
 
@@ -603,18 +601,18 @@ inline void GuRenderer::setMaxTextureOffsetByIndex(uint32 x, uint32 y) {
 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);		
+			sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0);
 
-	} else 
+	} else
 		sceGuDisable(GU_BLEND);
-	
+
 	if (_colorTest) {
 		sceGuEnable(GU_COLOR_TEST);
 		sceGuColorFunc(GU_NOTEQUAL, _keyColor, 0x00ffffff);
@@ -626,9 +624,9 @@ inline void GuRenderer::guProgramDrawBehavior() {
 
 inline void GuRenderer::guLoadPalette() {
 	DEBUG_ENTER_FUNC();
-	
+
 	uint32 mask;
-	
+
 	if (_buffer->getBitsPerPixel() == 4)
 		mask = 0x0F;
 	else if (_buffer->getBitsPerPixel() == 8)
@@ -637,70 +635,70 @@ inline void GuRenderer::guLoadPalette() {
 		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); 
-		
+	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;			
+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;
 }
@@ -708,19 +706,19 @@ inline Vertex *GuRenderer::guGetVertices() {
 // 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;
-	
+	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
@@ -730,15 +728,15 @@ void GuRenderer::fillVertices(Vertex *vertices) {
 	// 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) );
+	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;
@@ -751,52 +749,52 @@ void GuRenderer::fillVertices(Vertex *vertices) {
 	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;	
+		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 
+	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);
+
+	sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF | GU_VERTEX_32BITF | GU_TRANSFORM_2D, 2, 0, vertices);
 	DEBUG_EXIT_FUNC();
 }
 
diff --git a/backends/platform/psp/display_client.h b/backends/platform/psp/display_client.h
index d96504ad04..8d0f827415 100644
--- a/backends/platform/psp/display_client.h
+++ b/backends/platform/psp/display_client.h
@@ -22,7 +22,7 @@
  * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $
  *
  */
- 
+
 #ifndef PSP_GRAPHICS_H
 #define PSP_GRAPHICS_H
 
@@ -31,8 +31,8 @@
 #include "common/system.h"
 #include "backends/platform/psp/psppixelformat.h"
 #include "backends/platform/psp/memory.h"
- 
-#define MAX_TEXTURE_SIZE 512 
+
+#define MAX_TEXTURE_SIZE 512
 
 class DisplayManager;
 class GuRenderer;
@@ -50,13 +50,13 @@ public:
 	void render() {}
 	virtual ~DisplayClient() {}
 };
- 
+
 /**
  * Vertex used for GU rendering
  */
 struct Vertex {
-	float u,v;
-	float x,y,z;
+	float u, v;
+	float x, y, z;
 };
 
 struct Point {
@@ -101,7 +101,7 @@ public:
 	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
@@ -122,9 +122,9 @@ public:
 
 	Buffer() : _pixels(0), _width(0), _height(0)  {}
 	virtual ~Buffer() { deallocate(); }
-	
+
 	// setters
-	void setSize(uint32 width, uint32 height, HowToSize textureOrSource=kSizeByTextureSize);
+	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);
@@ -135,7 +135,7 @@ public:
 	uint32 getHeight() { return _height; }
 	uint32 getSourceWidth() { return _sourceSize.width; }
 	uint32 getSourceWidthInBytes() { return _pixelFormat.pixelsToBytes(_sourceSize.width); }
-	uint32 getSourceHeight() { return _sourceSize.height; }	
+	uint32 getSourceHeight() { return _sourceSize.height; }
 	uint32 getTextureWidth() { return _textureSize.width; }
 	uint32 getTextureHeight() { return _textureSize.height; }
 	PSPPixelFormat::Type getPixelFormat() { return _pixelFormat.format; }
@@ -143,7 +143,7 @@ public:
 	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);
@@ -155,7 +155,7 @@ public:
 	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;
@@ -163,7 +163,7 @@ protected:
 	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	
+	PSPPixelFormat _pixelFormat;	///< Format of the buffer
 };
 
 /**
@@ -177,19 +177,19 @@ public:
 	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;
+		_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 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; }
@@ -199,9 +199,9 @@ public:
 	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:
@@ -209,7 +209,7 @@ protected:
 	void fillVertices(Vertex *vertices);	// Fill in vertices with coordinates
 	void guProgramDrawBehavior();
 	Vertex *guGetVertices();
-	void guLoadTexture();	
+	void guLoadTexture();
 	void guLoadPalette();
 	void guProgramTextureFormat();
 	void guProgramTextureBitDepth();
@@ -218,7 +218,7 @@ protected:
 	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
diff --git a/backends/platform/psp/display_manager.cpp b/backends/platform/psp/display_manager.cpp
index a556a6e65f..0bec1c6278 100644
--- a/backends/platform/psp/display_manager.cpp
+++ b/backends/platform/psp/display_manager.cpp
@@ -48,7 +48,7 @@
 
 uint32 __attribute__((aligned(16))) MasterGuRenderer::_displayList[2048];
 
- const OSystem::GraphicsMode DisplayManager::_supportedModes[] = {
+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 },
@@ -61,13 +61,13 @@ uint32 __attribute__((aligned(16))) MasterGuRenderer::_displayList[2048];
 
 void MasterGuRenderer::guInit() {
 	DEBUG_ENTER_FUNC();
-	
+
 	sceGuInit();
 	sceGuStart(0, _displayList);
-	
+
 	guProgramDisplayBufferSizes();
-	
-	sceGuOffset(2048 - (PSP_SCREEN_WIDTH/2), 2048 - (PSP_SCREEN_HEIGHT/2));
+
+	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
@@ -77,13 +77,13 @@ void MasterGuRenderer::guInit() {
 	sceGuFrontFace(GU_CW);
 	sceGuEnable(GU_TEXTURE_2D);
 
-	sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT);
+	sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT);
 	sceGuFinish();
-	sceGuSync(0,0);
+	sceGuSync(0, 0);
 
 	sceDisplayWaitVblankStart();
 	sceGuDisplay(1);
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -91,7 +91,7 @@ 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);
@@ -106,7 +106,7 @@ void MasterGuRenderer::guProgramDisplayBufferSizes() {
 		VramAllocator::instance().allocate(PSP_FRAME_SIZE * sizeof(uint32) * 2);
 		break;
 	}
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -116,38 +116,38 @@ inline void MasterGuRenderer::guPreRender() {
 
 #ifdef ENABLE_RENDER_MEASURE
 	_lastRenderTime = g_system->getMillis();
-#endif /* ENABLE_RENDER_MEASURE */	
-	
+#endif /* ENABLE_RENDER_MEASURE */
+
 	sceGuStart(0, _displayList);
 
 	sceGuClearColor(0xFF000000);
 	sceGuClear(GU_COLOR_BUFFER_BIT);
-	
+
 	sceGuAmbientColor(0xFFFFFFFF);
 	sceGuColor(0xFFFFFFFF);
-	sceGuTexOffset(0,0);
+	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);
+	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();
 }
 
@@ -164,16 +164,16 @@ DisplayManager::~DisplayManager() {
 
 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();
 }
 
@@ -184,21 +184,21 @@ void DisplayManager::setSizeAndPixelFormat(uint width, uint height, const Graphi
 
 	_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();
 }
 
@@ -245,16 +245,16 @@ bool DisplayManager::setGraphicsMode(int mode) {
 	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.screenOutput.height && _displayParams.screenSource.height) {
 		_displayParams.scaleX = ((float)_displayParams.screenOutput.width) / _displayParams.screenSource.width;
 		_displayParams.scaleY = ((float)_displayParams.screenOutput.height) / _displayParams.screenSource.height;
 	}
@@ -268,43 +268,43 @@ void DisplayManager::renderAll() {
 		return;
 	}
 
-	if (!_screen->isDirty() && 
-		(!_overlay->isDirty()) && 
-		(!_cursor->isDirty()) && 
-		(!_keyboard->isDirty())) {
+	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"
-		);
+	                _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();
@@ -321,16 +321,16 @@ inline bool DisplayManager::isTimeToUpdate() {
 	_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;
 }
 
diff --git a/backends/platform/psp/display_manager.h b/backends/platform/psp/display_manager.h
index de5fcf94c8..54b4b78938 100644
--- a/backends/platform/psp/display_manager.h
+++ b/backends/platform/psp/display_manager.h
@@ -24,7 +24,7 @@
  */
 
 #ifndef PSP_DISPLAY_MAN_H
-#define PSP_DISPLAY_MAN_H 
+#define PSP_DISPLAY_MAN_H
 
 /**
  *	Class used only by DisplayManager to start/stop GU rendering
@@ -60,13 +60,13 @@ public:
 	};
 	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; }
+	uint32 getDefaultGraphicsMode() const { return STRETCHED_480X272; }
 	const OSystem::GraphicsMode* getSupportedGraphicsModes() const { return _supportedModes; }
 
 	// Setters
@@ -99,15 +99,15 @@ private:
 	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	
+	bool isTimeToUpdate();			// should we update the screen now
 };
 
 
diff --git a/backends/platform/psp/elf32.h b/backends/platform/psp/elf32.h
index a7cebe37dd..616cc4b4d2 100644
--- a/backends/platform/psp/elf32.h
+++ b/backends/platform/psp/elf32.h
@@ -23,10 +23,10 @@
  *
  */
 
- #ifndef BACKENDS_ELF_H
- #define BACKENDS_ELF_H
+#ifndef BACKENDS_ELF_H
+#define BACKENDS_ELF_H
 
- /* ELF stuff */
+/* ELF stuff */
 
 typedef unsigned short Elf32_Half, Elf32_Section;
 typedef unsigned int Elf32_Word, Elf32_Addr, Elf32_Off;
@@ -39,22 +39,21 @@ typedef Elf32_Half Elf32_Versym;
 /* ELF File format structures. Look up ELF structure for more details */
 
 // ELF header (contains info about the file)
-typedef struct
-{
-  unsigned char e_ident[EI_NIDENT];     /* Magic number and other info */
-  Elf32_Half    e_type;                 /* Object file type */
-  Elf32_Half    e_machine;              /* Architecture */
-  Elf32_Word    e_version;              /* Object file version */
-  Elf32_Addr    e_entry;                /* Entry point virtual address */
-  Elf32_Off     e_phoff;                /* Program header table file offset */
-  Elf32_Off     e_shoff;                /* Section header table file offset */
-  Elf32_Word    e_flags;                /* Processor-specific flags */
-  Elf32_Half    e_ehsize;               /* ELF header size in bytes */
-  Elf32_Half    e_phentsize;            /* Program header table entry size */
-  Elf32_Half    e_phnum;                /* Program header table entry count */
-  Elf32_Half    e_shentsize;            /* Section header table entry size */
-  Elf32_Half    e_shnum;                /* Section header table entry count */
-  Elf32_Half    e_shstrndx;             /* Section header string table index */
+typedef struct {
+	unsigned char e_ident[EI_NIDENT];     /* Magic number and other info */
+	Elf32_Half    e_type;                 /* Object file type */
+	Elf32_Half    e_machine;              /* Architecture */
+	Elf32_Word    e_version;              /* Object file version */
+	Elf32_Addr    e_entry;                /* Entry point virtual address */
+	Elf32_Off     e_phoff;                /* Program header table file offset */
+	Elf32_Off     e_shoff;                /* Section header table file offset */
+	Elf32_Word    e_flags;                /* Processor-specific flags */
+	Elf32_Half    e_ehsize;               /* ELF header size in bytes */
+	Elf32_Half    e_phentsize;            /* Program header table entry size */
+	Elf32_Half    e_phnum;                /* Program header table entry count */
+	Elf32_Half    e_shentsize;            /* Section header table entry size */
+	Elf32_Half    e_shnum;                /* Section header table entry count */
+	Elf32_Half    e_shstrndx;             /* Section header string table index */
 } Elf32_Ehdr;
 
 // Should be in e_ident
@@ -72,16 +71,15 @@ typedef struct
 
 
 // Program header (contains info about segment)
-typedef struct
-{
-  Elf32_Word    p_type;                 /* Segment type */
-  Elf32_Off     p_offset;               /* Segment file offset */
-  Elf32_Addr    p_vaddr;                /* Segment virtual address */
-  Elf32_Addr    p_paddr;                /* Segment physical address */
-  Elf32_Word    p_filesz;               /* Segment size in file */
-  Elf32_Word    p_memsz;                /* Segment size in memory */
-  Elf32_Word    p_flags;                /* Segment flags */
-  Elf32_Word    p_align;                /* Segment alignment */
+typedef struct {
+	Elf32_Word    p_type;                 /* Segment type */
+	Elf32_Off     p_offset;               /* Segment file offset */
+	Elf32_Addr    p_vaddr;                /* Segment virtual address */
+	Elf32_Addr    p_paddr;                /* Segment physical address */
+	Elf32_Word    p_filesz;               /* Segment size in file */
+	Elf32_Word    p_memsz;                /* Segment size in memory */
+	Elf32_Word    p_flags;                /* Segment flags */
+	Elf32_Word    p_align;                /* Segment alignment */
 } Elf32_Phdr;
 
 // p_type values
@@ -100,18 +98,17 @@ typedef struct
 #define PF_R	4	/* read */
 
 // Section header (contains info about section)
-typedef struct
-{
-  Elf32_Word    sh_name;                /* Section name (string tbl index) */
-  Elf32_Word    sh_type;                /* Section type */
-  Elf32_Word    sh_flags;               /* Section flags */
-  Elf32_Addr    sh_addr;                /* Section virtual addr at execution */
-  Elf32_Off     sh_offset;              /* Section file offset */
-  Elf32_Word    sh_size;                /* Section size in bytes */
-  Elf32_Word    sh_link;                /* Link to another section */
-  Elf32_Word    sh_info;                /* Additional section information */
-  Elf32_Word    sh_addralign;           /* Section alignment */
-  Elf32_Word    sh_entsize;             /* Entry size if section holds table */
+typedef struct {
+	Elf32_Word    sh_name;                /* Section name (string tbl index) */
+	Elf32_Word    sh_type;                /* Section type */
+	Elf32_Word    sh_flags;               /* Section flags */
+	Elf32_Addr    sh_addr;                /* Section virtual addr at execution */
+	Elf32_Off     sh_offset;              /* Section file offset */
+	Elf32_Word    sh_size;                /* Section size in bytes */
+	Elf32_Word    sh_link;                /* Link to another section */
+	Elf32_Word    sh_info;                /* Additional section information */
+	Elf32_Word    sh_addralign;           /* Section alignment */
+	Elf32_Word    sh_entsize;             /* Entry size if section holds table */
 } Elf32_Shdr;
 
 // sh_type values
@@ -139,14 +136,13 @@ typedef struct
 
 
 // Symbol entry (contain info about a symbol)
-typedef struct
-{
-  Elf32_Word    st_name;                /* Symbol name (string tbl index) */
-  Elf32_Addr    st_value;               /* Symbol value */
-  Elf32_Word    st_size;                /* Symbol size */
-  unsigned char st_info;                /* Symbol type and binding */
-  unsigned char st_other;               /* Symbol visibility */
-  Elf32_Section st_shndx;               /* Section index */
+typedef struct {
+	Elf32_Word    st_name;                /* Symbol name (string tbl index) */
+	Elf32_Addr    st_value;               /* Symbol value */
+	Elf32_Word    st_size;                /* Symbol size */
+	unsigned char st_info;                /* Symbol type and binding */
+	unsigned char st_other;               /* Symbol visibility */
+	Elf32_Section st_shndx;               /* Section index */
 } Elf32_Sym;
 
 // Extract from the st_info
@@ -175,10 +171,9 @@ typedef struct
 #define SHN_HIRESERVE 	0xFFFF
 
 // Relocation entry (info about how to relocate)
-typedef struct
-{
-  Elf32_Addr    r_offset;               /* Address */
-  Elf32_Word    r_info;                 /* Relocation type and symbol index */
+typedef struct {
+	Elf32_Addr    r_offset;               /* Address */
+	Elf32_Word    r_info;                 /* Relocation type and symbol index */
 } Elf32_Rel;
 
 // Access macros for the relocation info
@@ -211,4 +206,4 @@ typedef struct
 	__valgp; \
 })
 
- #endif /* BACKENDS_ELF_H */
+#endif /* BACKENDS_ELF_H */
diff --git a/backends/platform/psp/input.cpp b/backends/platform/psp/input.cpp
index bd33175f03..be0530ecf1 100644
--- a/backends/platform/psp/input.cpp
+++ b/backends/platform/psp/input.cpp
@@ -21,14 +21,14 @@
  * $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 
+// 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"
@@ -52,7 +52,7 @@ void InputHandler::init() {
 
 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();
@@ -70,17 +70,16 @@ bool InputHandler::getAllInputs(Common::Event &event) {
 
 	if (_keyboard->isVisible())
 		haveEvent = _keyboard->processInput(event, pad);
-	else 
+	else
 		haveEvent = getEvent(event, pad);
 
-	if (haveEvent)
-	{	
+	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;
 }
 
@@ -92,22 +91,22 @@ bool InputHandler::getEvent(Common::Event &event, SceCtrlData &pad) {
 
 	// Collect events from different sources
 	haveEvent = getDpadEvent(event, pad);
-		
+
 	if (!haveEvent)
 		haveEvent = getButtonEvent(event, pad);
-		
+
 	if (!haveEvent)
-		haveEvent = getNubEvent(event, pad);		
+		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;
 
@@ -131,7 +130,7 @@ bool InputHandler::getDpadEvent(Common::Event &event, SceCtrlData &pad) {
 		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;
@@ -139,8 +138,7 @@ bool InputHandler::getDpadEvent(Common::Event &event, SceCtrlData &pad) {
 			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
+		} 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';
@@ -153,7 +151,7 @@ bool InputHandler::getDpadEvent(Common::Event &event, SceCtrlData &pad) {
 			_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;
 	}
@@ -204,7 +202,7 @@ bool InputHandler::getButtonEvent(Common::Event &event, SceCtrlData &pad) {
 			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");	
+			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();
@@ -234,12 +232,12 @@ bool InputHandler::getButtonEvent(Common::Event &event, SceCtrlData &pad) {
 			} 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" );
+			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;
 }
@@ -248,7 +246,7 @@ bool InputHandler::getNubEvent(Common::Event &event, SceCtrlData &pad) {
 	DEBUG_ENTER_FUNC();
 
 	bool haveEvent = false;
-	int32 analogStepX = pad.Lx;		// Goes up to 255. 
+	int32 analogStepX = pad.Lx;		// Goes up to 255.
 	int32 analogStepY = pad.Ly;
 
 	int32 oldX = _cursor->getX();
@@ -256,27 +254,27 @@ bool InputHandler::getNubEvent(Common::Event &event, SceCtrlData &pad) {
 
 	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 (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);
-				}
+			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);
@@ -290,7 +288,7 @@ bool InputHandler::getNubEvent(Common::Event &event, SceCtrlData &pad) {
 			event.mouse.x = newX;
 			event.mouse.y = newY;
 			haveEvent = true;
-			
+
 			PSP_DEBUG_PRINT("Nub event. X[%d], Y[%d]\n", newX, newY);
 		}
 	}
@@ -301,17 +299,17 @@ bool InputHandler::getNubEvent(Common::Event &event, SceCtrlData &pad) {
 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	
+	else 				// between these points, dampen the response to 0
 		input = 0;
-	
-	
+
+
 	DEBUG_EXIT_FUNC();
-	return input;	
+	return input;
 }
diff --git a/backends/platform/psp/input.h b/backends/platform/psp/input.h
index 64775b9b1d..cd686d9e02 100644
--- a/backends/platform/psp/input.h
+++ b/backends/platform/psp/input.h
@@ -21,7 +21,7 @@
  * $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
@@ -37,7 +37,7 @@
 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; }
@@ -51,11 +51,11 @@ private:
 	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);	
+	bool getNubEvent(Common::Event &event, SceCtrlData &pad);
 	int32 modifyNubAxisMotion(int32 input);
 	Common::KeyCode translateDpad(int x, int y);
 };
diff --git a/backends/platform/psp/memory.cpp b/backends/platform/psp/memory.cpp
index 9cf7ba7c6c..ba7645cf56 100644
--- a/backends/platform/psp/memory.cpp
+++ b/backends/platform/psp/memory.cpp
@@ -23,12 +23,12 @@
  *
  */
 
-#include "common/scummsys.h" 
+#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__
@@ -37,7 +37,7 @@
 
 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);
@@ -47,11 +47,11 @@ void Copier::copy(byte *dst, const byte *src, uint32 bytes, PSPPixelFormat *form
 #ifdef __PSP_DEBUG_PRINT__
 	uint32 debugBytes = bytes;
 	const byte *debugDst = dst, *debugSrc = src;
-#endif	
+#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);
@@ -59,10 +59,10 @@ void Copier::copy(byte *dst, const byte *src, uint32 bytes, PSPPixelFormat *form
 				copy8(dst, src, bytes);	// no swap is possible on 8 bit
 			else
 				copy16((uint16 *)dst, (uint16 *)src, bytes, format);
-				
-			goto test;	
+
+			goto test;
 		}
-		
+
 		// Do the prefix: the part to get us aligned
 		if (prefixDst & 1) { 			// byte
 			copy8(dst, src, prefixDst);	// no swap available
@@ -72,7 +72,7 @@ void Copier::copy(byte *dst, const byte *src, uint32 bytes, PSPPixelFormat *form
 		if (bytes > prefixDst)	// check that we can afford to subtract from bytes
 			bytes -= prefixDst;
 		else {
-			DEBUG_EXIT_FUNC();	
+			DEBUG_EXIT_FUNC();
 			return;
 		}
 		dst32 = (uint32 *)(dst + prefixDst);
@@ -80,11 +80,11 @@ void Copier::copy(byte *dst, const byte *src, uint32 bytes, PSPPixelFormat *form
 	} 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);
@@ -107,13 +107,13 @@ void Copier::copy(byte *dst, const byte *src, uint32 bytes, PSPPixelFormat *form
 			copy16((uint16*)dst32, (uint16 *)src32, remainingBytes, format);
 	}
 
-test:	
+test:
 	// debug
 #ifdef __PSP_DEBUG_PRINT__
 	bool mismatch = false;
 
-	for (uint32 i=0; i<debugBytes; i++) {
-		if (debugDst[i] != debugSrc[i]) { 
+	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);
@@ -122,7 +122,7 @@ test:
 			PSP_DEBUG_PRINT_SAMELN("%x!=%x ", debugSrc[i], debugDst[i]);
 		}
 	}
-	if (mismatch) 
+	if (mismatch)
 		PSP_DEBUG_PRINT("\n");
 #endif
 
@@ -134,7 +134,7 @@ inline void Copier::copy8(byte *dst, const byte *src, uint32 bytes) {
 		*dst = *src;
 		dst++;
 		src++;
-	}	
+	}
 }
 
 inline void Copier::copy16(uint16 *dst, const uint16 *src, uint32 bytes, PSPPixelFormat *format /* = NULL */) {
@@ -147,7 +147,7 @@ inline void Copier::copy16(uint16 *dst, const uint16 *src, uint32 bytes, PSPPixe
 			*dst = format->swapRedBlue16(*src);
 			dst++;
 			src++;
-		}	
+		}
 	} else {
 		for (; shorts > 0 ; shorts--) {
 			*dst = *src;
@@ -158,8 +158,8 @@ inline void Copier::copy16(uint16 *dst, const uint16 *src, uint32 bytes, PSPPixe
 	if (remainingBytes)
 		*(byte *)dst = *(byte *)src;
 }
- 
- 
+
+
 // Class VramAllocator -----------------------------------
 
 DECLARE_SINGLETON(VramAllocator)
@@ -172,34 +172,34 @@ DECLARE_SINGLETON(VramAllocator)
 
 void *VramAllocator::allocate(int32 size, bool smallAllocation /* = false */) {
 	DEBUG_ENTER_FUNC();
-	assert (size > 0);
-	
+	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);
+		                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;
 }
@@ -208,9 +208,9 @@ void *VramAllocator::allocate(int32 size, bool smallAllocation /* = false */) {
 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) {
@@ -220,8 +220,8 @@ void VramAllocator::deallocate(void *address) {
 			DEBUG_EXIT_FUNC();
 			return;
 		}
-	}	
-	
+	}
+
 	PSP_DEBUG_PRINT("Address[%p] not allocated.\n", address);
 	DEBUG_EXIT_FUNC();
-}		
+}
diff --git a/backends/platform/psp/memory.h b/backends/platform/psp/memory.h
index 79af46c68b..a198095090 100644
--- a/backends/platform/psp/memory.h
+++ b/backends/platform/psp/memory.h
@@ -25,11 +25,11 @@
  */
 
 #ifndef PSP_MEMORY_H
-#define 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
  */
@@ -50,10 +50,10 @@ public:
 	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;
-}
+		if ((uint32)(CACHED(address)) >= VRAM_START_ADDRESS && (uint32)(CACHED(address)) < VRAM_END_ADDRESS)
+			return true;
+		return false;
+	}
 
 
 private:
@@ -71,10 +71,10 @@ private:
 	enum {
 		VRAM_START_ADDRESS = 0x04000000,
 		VRAM_END_ADDRESS   = 0x04200000,
-		VRAM_SMALL_ADDRESS = VRAM_END_ADDRESS - (4*1024)	// 4K in the end for small allocations
+		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 */
diff --git a/backends/platform/psp/osys_psp.cpp b/backends/platform/psp/osys_psp.cpp
index 022c10f5a8..bd81c14072 100644
--- a/backends/platform/psp/osys_psp.cpp
+++ b/backends/platform/psp/osys_psp.cpp
@@ -23,7 +23,7 @@
  *
  */
 
-#include <pspuser.h> 
+#include <pspuser.h>
 #include <pspgu.h>
 #include <pspdisplay.h>
 
@@ -70,7 +70,7 @@ void OSystem_PSP::initBackend() {
 
 	_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);
@@ -83,7 +83,7 @@ void OSystem_PSP::initBackend() {
 	_inputHandler.setKeyboard(&_keyboard);
 	_inputHandler.init();
 
-	initSDL();		
+	initSDL();
 
 	_savefile = new PSPSaveFileManager;
 
@@ -91,13 +91,13 @@ void OSystem_PSP::initBackend() {
 
 	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();
 }
 
@@ -127,27 +127,27 @@ int OSystem_PSP::getDefaultGraphicsMode() const {
 
 bool OSystem_PSP::setGraphicsMode(int mode) {
 	DEBUG_ENTER_FUNC();
-	
+
 	int ret = _displayManager.setGraphicsMode(mode);
-	
+
 	DEBUG_EXIT_FUNC();
 	return ret;
 }
 
 bool OSystem_PSP::setGraphicsMode(const char *name) {
 	DEBUG_ENTER_FUNC();
-	
+
 	int ret = _displayManager.setGraphicsMode(name);
-	
+
 	DEBUG_EXIT_FUNC();
 	return ret;
 }
 
 int OSystem_PSP::getGraphicsMode() const {
 	DEBUG_ENTER_FUNC();
-	
+
 	int ret = _displayManager.getGraphicsMode();
-	
+
 	DEBUG_EXIT_FUNC();
 	return ret;
 }
@@ -166,7 +166,7 @@ Common::List<Graphics::PixelFormat> OSystem_PSP::getSupportedFormats() {
 
 void OSystem_PSP::initSize(uint width, uint height, const Graphics::PixelFormat *format) {
 	DEBUG_ENTER_FUNC();
-	
+
 	_displayManager.setSizeAndPixelFormat(width, height, format);
 
 	_cursor.setVisible(false);
@@ -179,7 +179,7 @@ int16 OSystem_PSP::getWidth() {
 	DEBUG_ENTER_FUNC();
 
 	int16 ret = (int16)_screen.getWidth();
-	
+
 	DEBUG_EXIT_FUNC();
 	return ret;
 }
@@ -188,14 +188,14 @@ int16 OSystem_PSP::getHeight() {
 	DEBUG_ENTER_FUNC();
 
 	int16 ret = (int16)_screen.getHeight();
-	
+
 	DEBUG_EXIT_FUNC();
 	return ret;
 }
 
 void OSystem_PSP::setPalette(const byte *colors, uint start, uint num) {
 	DEBUG_ENTER_FUNC();
-	
+
 	_screen.setPartialPalette(colors, start, num);
 	_cursor.setScreenPalette(colors, start, num);
 	_cursor.clearKeyColor();
@@ -217,7 +217,7 @@ void OSystem_PSP::disableCursorPalette(bool disable) {
 	DEBUG_ENTER_FUNC();
 
 	_cursor.enableCursorPalette(!disable);
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -232,8 +232,8 @@ void OSystem_PSP::copyRectToScreen(const byte *buf, int pitch, int x, int y, int
 Graphics::Surface *OSystem_PSP::lockScreen() {
 	DEBUG_ENTER_FUNC();
 
-	Graphics::Surface *ret = _screen.lockAndGetForEditing();	
-	
+	Graphics::Surface *ret = _screen.lockAndGetForEditing();
+
 	DEBUG_EXIT_FUNC();
 	return ret;
 }
@@ -242,7 +242,7 @@ void OSystem_PSP::unlockScreen() {
 	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();
 }
 
@@ -250,16 +250,16 @@ void OSystem_PSP::updateScreen() {
 	DEBUG_ENTER_FUNC();
 
 	_displayManager.renderAll();
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
 void OSystem_PSP::setShakePos(int shakeOffset) {
-	DEBUG_ENTER_FUNC();	
+	DEBUG_ENTER_FUNC();
 
 	_screen.setShakePos(shakeOffset);
-	
-	DEBUG_EXIT_FUNC();	
+
+	DEBUG_EXIT_FUNC();
 }
 
 void OSystem_PSP::showOverlay() {
@@ -268,7 +268,7 @@ void OSystem_PSP::showOverlay() {
 	_overlay.setVisible(true);
 	_cursor.setLimits(_overlay.getWidth(), _overlay.getHeight());
 	_cursor.useGlobalScaler(false);	// mouse with overlay is 1:1
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -278,7 +278,7 @@ void OSystem_PSP::hideOverlay() {
 	_overlay.setVisible(false);
 	_cursor.setLimits(_screen.getWidth(), _screen.getHeight());
 	_cursor.useGlobalScaler(true);	// mouse needs to be scaled with screen
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -318,7 +318,7 @@ void OSystem_PSP::grabPalette(byte *colors, uint start, uint num) {
 	DEBUG_ENTER_FUNC();
 
 	_screen.getPartialPalette(colors, start, num);
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -328,17 +328,17 @@ bool OSystem_PSP::showMouse(bool v) {
 	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) {
 	DEBUG_ENTER_FUNC();
 
-	_cursor.setXY(x,y);
-	
+	_cursor.setXY(x, y);
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -349,14 +349,14 @@ void OSystem_PSP::setMouseCursor(const byte *buf, uint w, uint h, int hotspotX,
 	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);
 	}
-	
-	_cursor.setKeyColor(keycolor);	
+
+	_cursor.setKeyColor(keycolor);
 	_cursor.setCursorTargetScale(cursorTargetScale);
 	_cursor.setSizeAndScummvmPixelFormat(w, h, format);
 	_cursor.setHotspot(hotspotX, hotspotY);
 	_cursor.clearKeyColor();
 	_cursor.copyFromArray(buf);
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
diff --git a/backends/platform/psp/osys_psp.h b/backends/platform/psp/osys_psp.h
index 23eba870e9..8c5b40dcdf 100644
--- a/backends/platform/psp/osys_psp.h
+++ b/backends/platform/psp/osys_psp.h
@@ -43,7 +43,7 @@
 
 class OSystem_PSP : public BaseBackend {
 private:
-	
+
 	Common::SaveFileManager *_savefile;
 	Audio::MixerImpl *_mixer;
 	Common::TimerManager *_timer;
@@ -63,14 +63,14 @@ public:
 	~OSystem_PSP();
 
 	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;
@@ -81,25 +81,25 @@ public:
 	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();
@@ -109,7 +109,7 @@ public:
 	int16 getOverlayHeight();
 	int16 getOverlayWidth();
 	Graphics::PixelFormat getOverlayFormat() const { return Graphics::createPixelFormat<4444>(); }
-	
+
 	// Mouse related
 	bool showMouse(bool visible);
 	void warpMouse(int x, int y);
@@ -138,7 +138,7 @@ public:
 	static void mixCallback(void *sys, byte *samples, int len);
 	void setupMixer(void);
 	Audio::Mixer *getMixer() { return _mixer; }
-	
+
 	// Misc
 	Common::SaveFileManager *getSavefileManager() { return _savefile; }
 	FilesystemFactory *getFilesystemFactory() { return &PSPFilesystemFactory::instance(); }
diff --git a/backends/platform/psp/powerman.cpp b/backends/platform/psp/powerman.cpp
index b4391b0b8d..25afba4881 100644
--- a/backends/platform/psp/powerman.cpp
+++ b/backends/platform/psp/powerman.cpp
@@ -26,7 +26,7 @@
 //#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>
 
@@ -37,19 +37,19 @@ DECLARE_SINGLETON(PowerManager)
 
 // 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);
+	PSP_DEBUG_PRINT("PM status[%d]. Listcount[%d]. CriticalCount[%d]. ThreadId[%x]. Error[%d]\n",
+	                _PMStatus, _listCounter, _criticalCounter, sceKernelGetThreadId(), _error);
 }
 
 
- /*******************************************
+/*******************************************
 *
 *	Constructor
 *
 ********************************************/
 PowerManager::PowerManager() {
 	DEBUG_ENTER_FUNC();
-	
+
 	_flagMutex = NULL;					/* Init mutex handle */
 	_listMutex = NULL;					/* Init mutex handle */
 	_condSuspendable = NULL;			/* Init condition variable */
@@ -78,14 +78,14 @@ PowerManager::PowerManager() {
 	_suspendFlag = false;
 	_criticalCounter = 0;	// How many are in the critical section
 	_pauseFlag = 0;
-	_pauseFlagOld = 0; 
+	_pauseFlagOld = 0;
 	_pauseClientState = 0;
 	_listCounter = 0;
 	PMStatusSet(kInitDone);
 	_error = 0;
 
 	DEBUG_EXIT_FUNC();
- }
+}
 
 /*******************************************
 *
@@ -107,7 +107,7 @@ int PowerManager::registerSuspend(Suspendable *item) {
 	if (SDL_mutexV(_listMutex) != 0) {
 		PSP_ERROR("Couldn't unlock _listMutex[%p]\n", _listMutex);
 	}
-	
+
 	debugPM();
 
 	DEBUG_EXIT_FUNC();
@@ -123,7 +123,7 @@ int PowerManager::unregisterSuspend(Suspendable *item) {
 	DEBUG_ENTER_FUNC();
 	debugPM();
 
-	 // Unregister from stream list
+	// Unregister from stream list
 	if (SDL_mutexP(_listMutex) != 0) {
 		PSP_ERROR("Couldn't unlock _listMutex[%p]\n", _listMutex);
 	}
@@ -140,16 +140,16 @@ int PowerManager::unregisterSuspend(Suspendable *item) {
 
 	DEBUG_EXIT_FUNC();
 	return 0;
- }
+}
 
- /*******************************************
+/*******************************************
 *
 *	Destructor
 *
 ********************************************/
- PowerManager::~PowerManager() {
+PowerManager::~PowerManager() {
 	DEBUG_ENTER_FUNC();
- 
+
 	PMStatusSet(kDestroyPM);
 
 	SDL_DestroyCond(_condSuspendable);
@@ -163,9 +163,9 @@ int PowerManager::unregisterSuspend(Suspendable *item) {
 
 	SDL_DestroyMutex(_listMutex);
 	_listMutex = 0;
-	
+
 	DEBUG_EXIT_FUNC();
- }
+}
 
 /*******************************************
 *
@@ -186,8 +186,7 @@ void PowerManager::pollPauseEngine() {
 			g_engine->pauseEngine(true);
 			PSP_DEBUG_PRINT_FUNC("Pausing engine\n");
 			_pauseClientState = PowerManager::Paused;		// Tell PM we're done pausing
-		}
-		else if (!pause && _pauseClientState == PowerManager::Paused) {
+		} else if (!pause && _pauseClientState == PowerManager::Paused) {
 			g_engine->pauseEngine(false);
 			PSP_DEBUG_PRINT_FUNC("Unpausing for resume\n");
 			_pauseClientState = PowerManager::Unpaused;	// Tell PM we're in the middle of pausing
@@ -216,7 +215,7 @@ int PowerManager::blockOnSuspend()  {
 
 int PowerManager::beginCriticalSection(bool justBlock) {
 	DEBUG_ENTER_FUNC();
-	
+
 	int ret = NotBlocked;
 
 	if (SDL_mutexP(_flagMutex) != 0) {
@@ -290,7 +289,7 @@ int PowerManager::endCriticalSection() {
 	return ret;
 }
 
- /*******************************************
+/*******************************************
 *
 *	Callback function to be called to put every Suspendable to suspend
 *
diff --git a/backends/platform/psp/powerman.h b/backends/platform/psp/powerman.h
index 4a9167f2bf..03a873647b 100644
--- a/backends/platform/psp/powerman.h
+++ b/backends/platform/psp/powerman.h
@@ -31,25 +31,25 @@
 #include "common/singleton.h"
 #include "common/list.h"
 
- /*
-  *  Implement this class (interface) if you want to use PowerManager's suspend callback functionality
-  *
-  */
- class Suspendable {
- public:
+/*
+ *  Implement this class (interface) if you want to use PowerManager's suspend callback functionality
+ *
+ */
+class Suspendable {
+public:
 	virtual ~Suspendable() {}
 	virtual int suspend() = 0;
 	virtual int resume() = 0;
- };
+};
 
- /******************************************************************************************************
- *
- *  This class will call a Suspendable when the PSP goes to suspend/resumes. It also provides the ability to block
- *  a thread when the PSP is going to suspend/suspending, and to wake it up when the PSP is resumed.
- *	This ability is very useful for managing the PSPIoStream class, but may be found useful by other classes as well.
- *
- *******************************************************************************************************/
- class PowerManager: public Common::Singleton<PowerManager> {
+/******************************************************************************************************
+*
+*  This class will call a Suspendable when the PSP goes to suspend/resumes. It also provides the ability to block
+*  a thread when the PSP is going to suspend/suspending, and to wake it up when the PSP is resumed.
+*	This ability is very useful for managing the PSPIoStream class, but may be found useful by other classes as well.
+*
+*******************************************************************************************************/
+class PowerManager: public Common::Singleton<PowerManager> {
 
 public:
 	int blockOnSuspend();								/* block if suspending */
@@ -76,7 +76,7 @@ public:
 		Paused
 	};
 
- private:
+private:
 	friend class Common::Singleton<PowerManager>;
 	PowerManager();
 	~PowerManager();
@@ -125,12 +125,12 @@ public:
 	void PMStatusSet(PMState s) { _PMStatus = s; }
 	volatile int _PMStatus;							/* What the PM is doing */
 
- public:
- 	int getPMStatus() { return _PMStatus; }
+public:
+	int getPMStatus() { return _PMStatus; }
 
- };
+};
 
- // For easy access
+// For easy access
 #define PowerMan	PowerManager::instance()
 
 #endif /* POWERMAN_H */
diff --git a/backends/platform/psp/psp_main.cpp b/backends/platform/psp/psp_main.cpp
index c3770cb41f..15e8d5a856 100644
--- a/backends/platform/psp/psp_main.cpp
+++ b/backends/platform/psp/psp_main.cpp
@@ -26,10 +26,10 @@
 #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>
+#include <pspuser.h>
 #endif
 
 #include <psppower.h>
@@ -87,7 +87,7 @@ void MyExceptionHandler(PspDebugRegBlock *regs) {
  * Function that is called from _init in kernelmode before the
  * main thread is started in usermode.
  */
-__attribute__ ((constructor))
+__attribute__((constructor))
 void loaderInit() {
 	pspKernelSetKernelPC();
 	pspDebugInstallErrorHandler(MyExceptionHandler);
@@ -150,7 +150,7 @@ int main(void) {
 	SetupCallbacks();
 
 	static const char *argv[] = { "scummvm", NULL };
-	static int argc = sizeof(argv)/sizeof(char *)-1;
+	static int argc = sizeof(argv) / sizeof(char *) - 1;
 
 	g_system = new OSystem_PSP();
 	assert(g_system);
diff --git a/backends/platform/psp/pspkeyboard.cpp b/backends/platform/psp/pspkeyboard.cpp
index d6fa0621b9..d349b514e2 100644
--- a/backends/platform/psp/pspkeyboard.cpp
+++ b/backends/platform/psp/pspkeyboard.cpp
@@ -26,7 +26,7 @@
 //#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-solid/"	/* path to kbd.zip */
+#define PSP_KB_SHELL_PATH 	"ms0:/psp/game4xx/scummvm-solid/"	/* path to kbd.zip */
 #endif
 
 //#define __PSP_DEBUG_FUNCS__	/* For debugging the stack */
@@ -80,7 +80,7 @@ short PSPKeyboard::_modeChar[MODE_COUNT][5][6] = {
 	},
 	{	//symbols
 		{ K('!'),  K(')'), K('?'), K('('), K('<'), K('>') },
-		{ K('+'),  K('/'), K('='), K('\\'),K('\''),K('"') },
+		{ K('+'),  K('/'), K('='), K('\\'), K('\''), K('"') },
 		{ K(':'),  K(']'), K(';'), K('['), K('@'), K('#') },
 		{ K('-'),  K('}'), K('_'), K('{'), K('*'), K('$') },
 		{ K('\b'), K('.'), K(' '), K(','), K(0),   K(0)   }
@@ -108,7 +108,7 @@ const char *PSPKeyboard::_guiStrings[] = {
 // Constructor
 PSPKeyboard::PSPKeyboard() {
 	DEBUG_ENTER_FUNC();
-	
+
 	_init = false;			// we're not initialized yet
 	_prevButtons = 0;		// Reset previous buttons
 	_dirty = false;        	// keyboard needs redrawing
@@ -119,19 +119,19 @@ PSPKeyboard::PSPKeyboard() {
 	_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);	
-	
+	_renderer.setUseGlobalScaler(false);
+
 	DEBUG_EXIT_FUNC();
 }
 
 // Destructor
 PSPKeyboard::~PSPKeyboard() {
 	DEBUG_ENTER_FUNC();
-	
+
 	if (!_init) {
 		DEBUG_EXIT_FUNC();
 		return;
@@ -142,18 +142,17 @@ PSPKeyboard::~PSPKeyboard() {
 		_palettes[i].deallocate();
 	}
 	_init = false;
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
-void PSPKeyboard::setVisible(bool val) { 
+void PSPKeyboard::setVisible(bool val) {
 	if (val && _state == kInvisible && _init) {	// Check also that were loaded correctly
 		_lastState = _state;
-		_state = kMove; 
-	}
-	else if ( !val && _state != kInvisible) {
+		_state = kMove;
+	} else if (!val && _state != kInvisible) {
 		_lastState = _state;
-		_state = kInvisible; 
+		_state = kInvisible;
 	}
 	setDirty();
 }
@@ -161,34 +160,34 @@ void PSPKeyboard::setVisible(bool val) {
 /* move the position the keyboard is currently drawn at */
 void PSPKeyboard::moveTo(const int newX, const int 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) {
 	DEBUG_ENTER_FUNC();
-	
+
 	int newX = _movedX + amount;
 
 	if (newX > PSP_SCREEN_WIDTH - 5 || newX < 0 - 140) {	// clamp
 		DEBUG_EXIT_FUNC();
 		return;
-	}	
+	}
 	_movedX = newX;
 	setDirty();
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
 /* move the position the keyboard is currently drawn at */
 void PSPKeyboard::increaseKeyboardLocationY(int amount) {
 	DEBUG_ENTER_FUNC();
-	
+
 	int newY = _movedY + amount;
 
 	if (newY > PSP_SCREEN_HEIGHT - 5 || newY < 0 - 140)	{ // clamp
@@ -197,7 +196,7 @@ void PSPKeyboard::increaseKeyboardLocationY(int amount) {
 	}
 	_movedY = newY;
 	setDirty();
-	
+
 	DEBUG_EXIT_FUNC();
 }
 
@@ -205,8 +204,8 @@ void PSPKeyboard::increaseKeyboardLocationY(int amount) {
 void PSPKeyboard::render() {
 	DEBUG_ENTER_FUNC();
 
-	unsigned int currentBuffer = _mode<<1;
-	
+	unsigned int currentBuffer = _mode << 1;
+
 	// Draw the background letters
 	// Set renderer to current buffer & palette
 	_renderer.setBuffer(&_buffers[currentBuffer]);
@@ -215,14 +214,14 @@ void PSPKeyboard::render() {
 	_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]);
@@ -230,12 +229,12 @@ void PSPKeyboard::render() {
 	_renderer.setOffsetInBuffer(x * OrangeBlockSize, y * OrangeBlockSize);
 	_renderer.setDrawSize(OrangeBlockSize, OrangeBlockSize);
 	_renderer.render();
-	
-	DEBUG_EXIT_FUNC();		
+
+	DEBUG_EXIT_FUNC();
 }
 
 inline void PSPKeyboard::convertCursorToXY(CursorDirections cur, int &x, int &y) {
-	switch(cur) {
+	switch (cur) {
 	case kUp:
 		x = 1;
 		y = 0;
@@ -291,7 +290,7 @@ bool PSPKeyboard::load() {
 	}
 
 	int i;
-	
+
 	// Loop through all png images
 	for (i = 0; i < guiStringsSize; i++) {
 		uint32 height = 0, width = 0, paletteSize = 0;
@@ -326,13 +325,13 @@ bool PSPKeyboard::load() {
 			// Allocate memory for image
 			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
 				if (paletteSize <= 16) { // 4 bit
 					_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 = 16;
+				} else if (paletteSize <= 256) {			// 8-bit image
 					paletteSize = 256;
 					_buffers[i].setPixelFormat(PSPPixelFormat::Type_Palette_8bit);
 					_palettes[i].setPixelFormats(PSPPixelFormat::Type_4444, PSPPixelFormat::Type_Palette_8bit);
@@ -340,11 +339,11 @@ bool PSPKeyboard::load() {
 					PSP_ERROR("palette of %d too big!\n", paletteSize);
 					goto ERROR;
 				}
-				
+
 			} else {				// 32-bit image
 				_buffers[i].setPixelFormat(PSPPixelFormat::Type_8888);
 			}
-			
+
 			_buffers[i].allocate();
 			_palettes[i].allocate();
 
@@ -361,13 +360,12 @@ bool PSPKeyboard::load() {
 
 				delete file;
 			}
-		}
-		else {
+		} else {
 			PSP_ERROR("couldn't obtain PNG image size\n");
 			goto ERROR;
 		}
 	} /* for loop */
-	
+
 	_init = true;
 
 	delete fileArchive;
@@ -387,7 +385,7 @@ ERROR:
 		_palettes[j].deallocate();
 	}
 	_init = false;
-	
+
 	DEBUG_EXIT_FUNC();
 	return false;
 }
@@ -399,7 +397,7 @@ static void user_warning_fn(png_structp png_ptr, png_const_charp warning_msg) {
 /* Get the width and height of a png image */
 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;
@@ -433,7 +431,7 @@ int PSPKeyboard::getPngImageSize(Common::SeekableReadStream *file, uint32 *png_w
 
 	*png_width = width;
 	*png_height = height;
-	
+
 	DEBUG_EXIT_FUNC();
 	return 0;
 }
@@ -442,7 +440,7 @@ int PSPKeyboard::getPngImageSize(Common::SeekableReadStream *file, uint32 *png_w
 //
 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;
@@ -480,7 +478,7 @@ int PSPKeyboard::loadPngImage(Common::SeekableReadStream *file, Buffer &buffer,
 	if (color_type == PNG_COLOR_TYPE_PALETTE) {
 		// Copy the palette
 		png_colorp srcPal = info_ptr->palette;
-		for(int i=0; i < info_ptr->num_palette; i++) {
+		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
 			palette.setSingleColorRGBA(i, srcPal->red, srcPal->green, srcPal->blue, alphaVal);
 			srcPal++;
@@ -492,7 +490,7 @@ int PSPKeyboard::loadPngImage(Common::SeekableReadStream *file, Buffer &buffer,
 		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);
-	}	
+	}
 
 	unsigned char *line = (unsigned char*) malloc(info_ptr->rowbytes);
 	if (!line) {
@@ -509,7 +507,7 @@ int PSPKeyboard::loadPngImage(Common::SeekableReadStream *file, Buffer &buffer,
 	}
 
 	free(line);
-	
+
 	png_read_end(png_ptr, info_ptr);
 	png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
 
@@ -533,21 +531,20 @@ int PSPKeyboard::loadPngImage(Common::SeekableReadStream *file, Buffer &buffer,
  */
 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;	
+		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
+	} 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;
@@ -555,7 +552,7 @@ bool PSPKeyboard::processInput(Common::Event &event, SceCtrlData &pad) {
 		_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);
@@ -569,7 +566,7 @@ bool PSPKeyboard::processInput(Common::Event &event, SceCtrlData &pad) {
 		handleLTriggerDownState(pad);	// Deal with trigger states
 
 	_prevButtons = pad.Buttons;
-	
+
 	DEBUG_EXIT_FUNC();
 	return haveEvent;
 }
@@ -578,7 +575,7 @@ void PSPKeyboard::handleMoveState(SceCtrlData &pad) {
 	DEBUG_ENTER_FUNC();
 	if (UP(PSP_CTRL_SELECT)) {
 		// Toggle between visible and invisible
-		_state = (_lastState == kInvisible) ? kDefault : kInvisible;		
+		_state = (_lastState == kInvisible) ? kDefault : kInvisible;
 		_dirty = true;
 
 		if (_moved) {					// We moved the keyboard. Keep the keyboard onscreen anyway
@@ -598,22 +595,22 @@ void PSPKeyboard::handleMoveState(SceCtrlData &pad) {
 		else  /* DOWN(PSP_CTRL_RIGHT) */
 			increaseKeyboardLocationX(5);
 	}
-	DEBUG_EXIT_FUNC();	
+	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;		
+		_state = kLTriggerDown;
 	else if (PRESSED(PSP_CTRL_RTRIGGER)) 	// Don't say we used up the input
-		_state = kRTriggerDown;		
+		_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;
 }
@@ -622,13 +619,13 @@ bool PSPKeyboard::handleCornersSelectedState(Common::Event &event, SceCtrlData &
 	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();	
+
+		DEBUG_EXIT_FUNC();
 	return haveEvent;
 }
 
@@ -670,13 +667,13 @@ bool PSPKeyboard::getInputChoice(Common::Event &event, SceCtrlData &pad) {
 	} 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 */ {
+	} 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')
+#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];
@@ -699,13 +696,13 @@ bool PSPKeyboard::getInputChoice(Common::Event &event, SceCtrlData &pad) {
 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;			
+		_state = kCornersSelected;
 
 		if (DOWN(PSP_CTRL_UP))
 			cursor = kUp;
@@ -716,7 +713,7 @@ void PSPKeyboard::getCursorMovement(SceCtrlData &pad) {
 		else if (DOWN(PSP_CTRL_LEFT))
 			cursor = kLeft;
 	}
-	
+
 	if (cursor != _oldCursor) { //If we've moved, update dirty and return
 		_dirty = true;
 		_oldCursor = cursor;
@@ -729,7 +726,7 @@ void PSPKeyboard::handleLTriggerDownState(SceCtrlData &pad) {
 	if (UNPRESSED(PSP_CTRL_LTRIGGER)) {
 		_dirty = true;
 
-		if(_mode < 2)
+		if (_mode < 2)
 			_mode = 2;
 		else
 			_mode = (_mode == 2) ? 3 : 2;
@@ -744,7 +741,7 @@ void PSPKeyboard::handleRTriggerDownState(SceCtrlData &pad) {
 	if (UNPRESSED(PSP_CTRL_RTRIGGER)) {
 		_dirty = true;
 
-		if(_mode > 1)
+		if (_mode > 1)
 			_mode = 0;
 		else
 			_mode = (_mode == 0) ? 1 : 0;
diff --git a/backends/platform/psp/pspkeyboard.h b/backends/platform/psp/pspkeyboard.h
index 457476e844..08c5bc4505 100644
--- a/backends/platform/psp/pspkeyboard.h
+++ b/backends/platform/psp/pspkeyboard.h
@@ -50,7 +50,7 @@ private:
 public:
 	PSPKeyboard();
 	~PSPKeyboard();
-	
+
 	bool load();												// Load keyboard into memory
 	bool isInit() { return _init; }								// Check for initialization
 	bool isDirty() { return _dirty; }							// Check if needs redrawing
@@ -89,19 +89,19 @@ private:
 	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;
 	uint32 _prevButtons;	// A bit pattern.
 	uint32 _buttonsChanged;
-	
+
 	bool _dirty;        		// keyboard needs redrawing
 	int _mode;          		// charset selected. (0 - letters or 1 - numbers)
 	int _movedX;				// location we've moved the KB to onscreen
 	int _movedY;
 	bool _moved;				// whether the keyboard was moved
-	
+
 	State _state;				// State of keyboard Keyboard state machine
 	State _lastState;
 
diff --git a/backends/platform/psp/psploader.cpp b/backends/platform/psp/psploader.cpp
index 94310936f6..68e51c1a50 100644
--- a/backends/platform/psp/psploader.cpp
+++ b/backends/platform/psp/psploader.cpp
@@ -134,7 +134,7 @@ bool DLObject::relocate(int fd, unsigned long offset, unsigned long size, void *
 
 		case R_MIPS_HI16:						// Absolute addressing.
 			if (sym->st_shndx < SHN_LOPROC &&		// Only shift for plugin section (ie. has a real section index)
-					firstHi16 < 0 ) {				// Only process first in block of HI16s
+			        firstHi16 < 0) {				// Only process first in block of HI16s
 				firstHi16 = i;						// Keep the first Hi16 we saw
 				seenHi16 = true;
 				ahl = (*target & 0xffff) << 16;		// Take lower 16 bits shifted up
@@ -174,8 +174,7 @@ bool DLObject::relocate(int fd, unsigned long offset, unsigned long size, void *
 				// Fix: we can have LO16 access to the short segment sometimes
 				if (lo16InShorts) {
 					relocation = ahl + _shortsSegment->getOffset();		// Add in the short segment offset
-				}
-				else	// It's in the regular segment
+				} else	// It's in the regular segment
 					relocation = ahl + (Elf32_Addr)_segment;			// Add in the new offset for the segment
 
 				if (firstHi16 >= 0) {					// We haven't treated the HI16s yet so do it now
diff --git a/backends/platform/psp/psppixelformat.cpp b/backends/platform/psp/psppixelformat.cpp
index 7758f2c26b..10b5aa5a7f 100644
--- a/backends/platform/psp/psppixelformat.cpp
+++ b/backends/platform/psp/psppixelformat.cpp
@@ -23,8 +23,8 @@
  *
  */
 
-#include "common/scummsys.h" 
-#include "backends/platform/psp/psppixelformat.h" 
+#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 */
@@ -36,10 +36,10 @@
 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:
@@ -71,12 +71,12 @@ void PSPPixelFormat::set(Type type, bool swap /* = false */) {
 // 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) {
+        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;
@@ -92,7 +92,7 @@ void PSPPixelFormat::convertFromScummvmPixelFormat(const Graphics::PixelFormat *
 			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)
@@ -104,13 +104,13 @@ void PSPPixelFormat::convertFromScummvmPixelFormat(const Graphics::PixelFormat *
 		} 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
+		           (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);		
+			          pf->rLoss, pf->gLoss, pf->bLoss, pf->aLoss,
+			          pf->rShift, pf->gShift, pf->bShift, pf->aShift);
 			*target = Type_Unknown;
 		}
 
@@ -123,44 +123,68 @@ void PSPPixelFormat::convertFromScummvmPixelFormat(const Graphics::PixelFormat *
 
 Graphics::PixelFormat PSPPixelFormat::convertToScummvmPixelFormat(PSPPixelFormat::Type type) {
 	Graphics::PixelFormat pf;
-	
-	switch(type) {
+
+	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; 
+		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; 
+		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; 
+		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;
+		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;
-	
+	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;
 }
diff --git a/backends/platform/psp/psppixelformat.h b/backends/platform/psp/psppixelformat.h
index 8a7283df43..2c74469f95 100644
--- a/backends/platform/psp/psppixelformat.h
+++ b/backends/platform/psp/psppixelformat.h
@@ -23,19 +23,19 @@
  *
  */
 
-#ifndef PSP_PIXEL_FORMAT_H 
+#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{
+struct PSPPixelFormat {
 	enum Type {
 		Type_None,
 		Type_4444,
@@ -44,9 +44,9 @@ struct PSPPixelFormat{
 		Type_8888,
 		Type_Palette_8bit,
 		Type_Palette_4bit,
-		Type_Unknown		
+		Type_Unknown
 	};
-	
+
 	Type format;
 	uint32 bitsPerPixel;					///< Must match bpp of selected type
 	bool swapRB;							///< Swap red and blue values when reading and writing
@@ -54,16 +54,16 @@ struct PSPPixelFormat{
 	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);
+	        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) {
+
+		switch (format) {
 		case Type_4444:
 			color = (((b >> 4) << 8) | ((g >> 4) << 4) | ((r >> 4) << 0) | ((a >> 4) << 12));
 			break;
@@ -84,7 +84,7 @@ struct PSPPixelFormat{
 	}
 
 	inline void colorToRgba(uint32 color, uint32 &r, uint32 &g, uint32 &b, uint32 &a) {
-		switch(format) {
+		switch (format) {
 		case Type_4444:
 			a = (color >> 12) & 0xF; // Interpolate to get true colors
 			b = (color >> 8)  & 0xF;
@@ -126,7 +126,7 @@ struct PSPPixelFormat{
 	}
 
 	inline uint32 setColorAlpha(uint32 color, byte alpha) {
-		switch(format) {
+		switch (format) {
 		case Type_4444:
 			color = (color & 0x0FFF) | (((uint32)alpha >> 4) << 12);
 			break;
@@ -134,7 +134,7 @@ struct PSPPixelFormat{
 			color = (color & 0x7FFF) | (((uint32)alpha >> 7) << 15);
 			break;
 		case Type_8888:
-			color = (color & 0x00FFFFFF) | ((uint32)alpha << 24); 
+			color = (color & 0x00FFFFFF) | ((uint32)alpha << 24);
 			break;
 		case Type_5650:
 		default:
@@ -142,7 +142,7 @@ struct PSPPixelFormat{
 		}
 		return color;
 	}
-	
+
 	inline uint32 pixelsToBytes(uint32 pixels) {
 		switch (bitsPerPixel) {
 		case 4:
@@ -165,51 +165,51 @@ struct PSPPixelFormat{
 
 	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;
+		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;
+		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;
 	}
 
@@ -220,10 +220,10 @@ struct PSPPixelFormat{
 		switch (bitsPerPixel) {
 		case 4:	// We can't distinguish a 4 bit color with a pointer
 		case 8:
-			result = (uint32)*pointer;
+			result = (uint32) * pointer;
 			break;
 		case 16:
-			result = (uint32)*(uint16 *)pointer;
+			result = (uint32) * (uint16 *)pointer;
 			break;
 		case 32:
 			result = *(uint32 *)pointer;
@@ -234,7 +234,7 @@ struct PSPPixelFormat{
 			break;
 		}
 		return result;
-	}	
+	}
 };
- 
-#endif /* PSP_PIXEL_FORMAT_H */ 
+
+#endif /* PSP_PIXEL_FORMAT_H */
diff --git a/backends/platform/psp/trace.cpp b/backends/platform/psp/trace.cpp
index 030dafdf1d..872e1aabf4 100644
--- a/backends/platform/psp/trace.cpp
+++ b/backends/platform/psp/trace.cpp
@@ -31,25 +31,25 @@
 
 int psp_debug_indent = 0;
 
-void PSPDebugTrace (bool alsoToScreen, const char *format, ...) {
+void PSPDebugTrace(bool alsoToScreen, const char *format, ...) {
 	va_list	opt;
 	char		buffer[2048];
 	int			bufsz;
 	FILE *fd = 0;
 
 	va_start(opt, format);
-	bufsz = vsnprintf( buffer, (size_t) sizeof(buffer), format, opt);
+	bufsz = vsnprintf(buffer, (size_t) sizeof(buffer), format, opt);
 	va_end(opt);
 
 	//fd = fopen("MS0:/SCUMMTRACE.TXT", "ab");
 	fd = fopen("SCUMMTRACE.TXT", "ab");
-	
+
 	if (fd == 0)
 		return;
 
 	fwrite(buffer, 1, bufsz, fd);
 	fclose(fd);
-	
+
 	if (alsoToScreen)
 		fprintf(stderr, buffer);
 }
diff --git a/backends/platform/psp/trace.h b/backends/platform/psp/trace.h
index b77ecb4732..024da11373 100644
--- a/backends/platform/psp/trace.h
+++ b/backends/platform/psp/trace.h
@@ -38,7 +38,7 @@
 //#define __PSP_DEBUG_FUNCS__	/* can put this locally too */
 //#define __PSP_DEBUG_PRINT__
 
-void PSPDebugTrace (bool alsoToScreen, const char *format, ...);
+void PSPDebugTrace(bool alsoToScreen, const char *format, ...);
 
 #ifndef TRACE_C
 extern int psp_debug_indent;
@@ -62,19 +62,19 @@ extern int psp_debug_indent;
 
 /* Choose to print to file/screen/both */
 #ifdef __PSP_PRINT_TO_FILE__
-	#define __PSP_PRINT__(format,...)			PSPDebugTrace(false, format, ## __VA_ARGS__)
+#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__)
+#define __PSP_PRINT__(format,...)			PSPDebugTrace(true, format, ## __VA_ARGS__)
 #else /* default - print to screen */
- 	#define __PSP_PRINT__(format,...)			fprintf(stderr, format, ## __VA_ARGS__)
+#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__( "   ") 
+													__PSP_PRINT__( "   ")
 
 /* always print */
 #define PSP_INFO_PRINT(format,...)				__PSP_PRINT__(format, ## __VA_ARGS__)
@@ -83,36 +83,36 @@ extern int psp_debug_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__; \
+/* 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__; \
+#define PSP_DEBUG_PRINT_FUNC(format,...)	{ __PSP_INDENT__; \
 												__PSP_PRINT__("In %s: " format, __PRETTY_FUNCTION__, ## __VA_ARGS__); }
-	#define PSP_DEBUG_DO(x)						(x)						
+#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)	
+#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--; \
+#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 */
-							
+#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
+#define DEBUG_ENTER_FUNC()
+#define DEBUG_EXIT_FUNC()
+#define INLINE						inline
 #endif /* __PSP_DEBUG_FUNCS__ */
 
 // Undef the main defines for next time