From 3d84f1104688db0b23b6fe9ccc86b587ac597837 Mon Sep 17 00:00:00 2001 From: Eugene Sandulenko Date: Fri, 6 Oct 2006 19:01:39 +0000 Subject: Patch #1432376: "Very basic GP2X Backend" svn-id: r24144 --- backends/intern.h | 3 + backends/platform/gp2x/build.rules | 5 + backends/platform/gp2x/build/README-GP2X | 114 ++ backends/platform/gp2x/build/README-GP2X.html | 114 ++ backends/platform/gp2x/build/build.sh | 19 + backends/platform/gp2x/build/bundle.sh | 30 + backends/platform/gp2x/build/clean.sh | 17 + backends/platform/gp2x/build/config.sh | 22 + backends/platform/gp2x/build/scummvm.png | Bin 0 -> 2810 bytes backends/platform/gp2x/events.cpp | 657 ++++++++++ backends/platform/gp2x/gp2x-common.h | 402 ++++++ backends/platform/gp2x/gp2x-hw.cpp | 248 ++++ backends/platform/gp2x/gp2x-hw.h | 74 ++ backends/platform/gp2x/gp2x-mem.c | 300 +++++ backends/platform/gp2x/gp2x-mem.h | 57 + backends/platform/gp2x/gp2x.cpp | 298 +++++ backends/platform/gp2x/graphics.cpp | 1722 +++++++++++++++++++++++++ backends/platform/gp2x/module.mk | 15 + common/config-manager.cpp | 8 +- configure | 29 +- sound/fmopl.cpp | 10 +- 21 files changed, 4134 insertions(+), 10 deletions(-) create mode 100644 backends/platform/gp2x/build.rules create mode 100644 backends/platform/gp2x/build/README-GP2X create mode 100644 backends/platform/gp2x/build/README-GP2X.html create mode 100644 backends/platform/gp2x/build/build.sh create mode 100644 backends/platform/gp2x/build/bundle.sh create mode 100644 backends/platform/gp2x/build/clean.sh create mode 100644 backends/platform/gp2x/build/config.sh create mode 100644 backends/platform/gp2x/build/scummvm.png create mode 100644 backends/platform/gp2x/events.cpp create mode 100644 backends/platform/gp2x/gp2x-common.h create mode 100644 backends/platform/gp2x/gp2x-hw.cpp create mode 100644 backends/platform/gp2x/gp2x-hw.h create mode 100644 backends/platform/gp2x/gp2x-mem.c create mode 100644 backends/platform/gp2x/gp2x-mem.h create mode 100644 backends/platform/gp2x/gp2x.cpp create mode 100644 backends/platform/gp2x/graphics.cpp create mode 100644 backends/platform/gp2x/module.mk diff --git a/backends/intern.h b/backends/intern.h index f6304fb7b5..8a20e45702 100644 --- a/backends/intern.h +++ b/backends/intern.h @@ -43,6 +43,9 @@ #elif defined(__PSP__) #define SAMPLES_PER_SEC 44100 +#elif defined(__GP2X__) +#define SAMPLES_PER_SEC 11025 + #elif defined(PALMOS_MODE) # ifdef PALMOS_ARM # ifdef COMPILE_ZODIAC diff --git a/backends/platform/gp2x/build.rules b/backends/platform/gp2x/build.rules new file mode 100644 index 0000000000..1a1134d2ac --- /dev/null +++ b/backends/platform/gp2x/build.rules @@ -0,0 +1,5 @@ +# Build settings for the GP2X backend +MODULES += backends/gp2x +DEFINES += -DUNIX -DGP2X +INCLUDES += `sdl-config --cflags` +LIBS += `sdl-config --libs` diff --git a/backends/platform/gp2x/build/README-GP2X b/backends/platform/gp2x/build/README-GP2X new file mode 100644 index 0000000000..acc3d0d140 --- /dev/null +++ b/backends/platform/gp2x/build/README-GP2X @@ -0,0 +1,114 @@ +$URL$ +$Id$ + +DO NOT USE THIS FOR ANYTHING OTHER THEN TO TEST A USB MOUSE. +IT'S BUGGY AND ANYTHING OTHER THEN THE 320*2xx LucasArts GAMES +WILL MOST LIGHTLY CRASH YOUR GP2X. + +THE README IS BELOW JUST FOR REFERANCE. + +ScummVM for the GP2X - UNSTABLE MOUSE TEST - 0.10.0 SVN +------------------------------------------------------- + +This is a test release of ScummVM for the GP2X, it would be appreciated if this alpha test distribution was not mirrored and that people be directed to http://www.distant-earth.com/scummvm instead, until the port is a little more mature, to ensure people download the most recent builds. + +This build is still in a very heavy state of development and as such no ‘expected’ behaviour can be guaranteed ;). +I tested with firmware 1.2.1 for reference. + +INCLUDED ENGINES: + +Scumm - (All games supported by ScummVM should work to some extent, using the hardware scalar if needed) + +// Simon - (Simon the Sorcerer one and two) +// Sky - (Beneath a Steel Sky) +// Sword - (Broken Sword 1) - This engine uses the hardware scalar to downsize the graphics to fix on the GP2X. It is NOT very nice to look at. +// Sword2 - (Broken Sword 2) - This engine uses the hardware scalar to downsize the graphics to fix on the GP2X. It is NOT very nice to look at. +// Gob - (Goblins one) +// Queen - Flight of the Amazon Queen +// Kyra - (The Legend of Kyrandia) - This engine is still under heavy development in ScummVM, however the game is playable. +// Lure - (Lure of the Temptress) - This engine is still under heavy development in ScummVM, the game is not yet really playable. + + +All other game engines are disabled in this release. + +SUPPORTED AUDIO OPTIONS: + +Raw audio. +MP3 audio. +OGG Vorbis audio (this may be problematic, I just made some big changes to my Tremor code). + +RECENT CHANGES: + +Refined audio hacks to reduce audio delay a little more. +Enabled hardware scalar code. +Now built using SDL 1.2.9 for the parts of the port that use SDL (some parts now hit the hardware directly). +Enabled new launcher - (Ensure defaulttheme.zip is in the same folder as the executable). +Aspect Ratio Correction can now be disabled ‘per game’. When adding a game you can find this option on the GFX tab. +Note: This will cause the game to run with a black border at the bottom as it will be rendered to a 320*200 frame. + +HOW TO SAVE: + +NOTE: Everything is saved to the SD card, saves are stored in the game folder, and the config file for ScummVM (.scummvmrc) is stored in the same place as the GPE. + +Ok, this is for Scumm engine games but the principle is the same for all. + +In Game. + +1. Right Trigger +2. Select SAVE with B +3. Select a position with B +4. Right trigger puts ? in the name box for some text. +5. Press B to save + +Basically the emulated keys you have are what I mapped the buttons to, +I have a virtual keyboard like the GP32 one (left/right on the stick to pick chars) to add in at some point ;-) + +CONTROLLER MAPPING: + +NOTE: The controller mappings have recently changed somewhat so please review the new setup. +This is subject to change; it still does not ‘feel’ quite right. + +Mouse Emulation: + +Stick: Move Pointer +Stick Click: ‘light’ Left Click +B: Left click +X: Right click + +Keyboard Emulation: + +Start: Return +Select: Escape +Y: Space Bar (Pause) +Right Trigger: Game Menu (Save, Load, Quit etc.) +Volume Buttons: Increase and Decrease volume (5% per press) + +Fancy button combos: + +NOTE: To use button combos press and hold the Left Trigger then... + +Volume Buttons: Increase and Decrease subtitle speed (In SCUMM games) +Right Trigger: 0 (For skipping the copy protection in Monkey Island 2) +Select: Exit ScummVM completely +(More to add, ideas please) + +KNOWN ISSUES: + +Possible random crash (well SegFault). I have had this happen twice and have not tracked down the cause. +It happens very infrequently, both times it was in the DOTT CD intro. Saving often is never a bad idea anyhow. + +Volume level changes can be a little inconsistent at times. + +MAJOR TODOS: + +Fix save support when using the Sky engine (Beneath a Steel Sky) - You CAN'T save at the moment but auto save works. +Look into inconsistencies with Simon engine and map Y key to a button combination to allow clean quitting (Simon 1/2). +Add splash-screen and pre-ScummVM config menu (CPU speed, LCD timings etc.) - Partly done. +Fix TV out, maybe make it an option in the pre-ScummVM config menu. +Any help appreciated :). + +SOURCE: + +Port source is available on request. Note this is development code (and VERY messy). + +John Willis \ No newline at end of file diff --git a/backends/platform/gp2x/build/README-GP2X.html b/backends/platform/gp2x/build/README-GP2X.html new file mode 100644 index 0000000000..acc3d0d140 --- /dev/null +++ b/backends/platform/gp2x/build/README-GP2X.html @@ -0,0 +1,114 @@ +$URL$ +$Id$ + +DO NOT USE THIS FOR ANYTHING OTHER THEN TO TEST A USB MOUSE. +IT'S BUGGY AND ANYTHING OTHER THEN THE 320*2xx LucasArts GAMES +WILL MOST LIGHTLY CRASH YOUR GP2X. + +THE README IS BELOW JUST FOR REFERANCE. + +ScummVM for the GP2X - UNSTABLE MOUSE TEST - 0.10.0 SVN +------------------------------------------------------- + +This is a test release of ScummVM for the GP2X, it would be appreciated if this alpha test distribution was not mirrored and that people be directed to http://www.distant-earth.com/scummvm instead, until the port is a little more mature, to ensure people download the most recent builds. + +This build is still in a very heavy state of development and as such no ‘expected’ behaviour can be guaranteed ;). +I tested with firmware 1.2.1 for reference. + +INCLUDED ENGINES: + +Scumm - (All games supported by ScummVM should work to some extent, using the hardware scalar if needed) + +// Simon - (Simon the Sorcerer one and two) +// Sky - (Beneath a Steel Sky) +// Sword - (Broken Sword 1) - This engine uses the hardware scalar to downsize the graphics to fix on the GP2X. It is NOT very nice to look at. +// Sword2 - (Broken Sword 2) - This engine uses the hardware scalar to downsize the graphics to fix on the GP2X. It is NOT very nice to look at. +// Gob - (Goblins one) +// Queen - Flight of the Amazon Queen +// Kyra - (The Legend of Kyrandia) - This engine is still under heavy development in ScummVM, however the game is playable. +// Lure - (Lure of the Temptress) - This engine is still under heavy development in ScummVM, the game is not yet really playable. + + +All other game engines are disabled in this release. + +SUPPORTED AUDIO OPTIONS: + +Raw audio. +MP3 audio. +OGG Vorbis audio (this may be problematic, I just made some big changes to my Tremor code). + +RECENT CHANGES: + +Refined audio hacks to reduce audio delay a little more. +Enabled hardware scalar code. +Now built using SDL 1.2.9 for the parts of the port that use SDL (some parts now hit the hardware directly). +Enabled new launcher - (Ensure defaulttheme.zip is in the same folder as the executable). +Aspect Ratio Correction can now be disabled ‘per game’. When adding a game you can find this option on the GFX tab. +Note: This will cause the game to run with a black border at the bottom as it will be rendered to a 320*200 frame. + +HOW TO SAVE: + +NOTE: Everything is saved to the SD card, saves are stored in the game folder, and the config file for ScummVM (.scummvmrc) is stored in the same place as the GPE. + +Ok, this is for Scumm engine games but the principle is the same for all. + +In Game. + +1. Right Trigger +2. Select SAVE with B +3. Select a position with B +4. Right trigger puts ? in the name box for some text. +5. Press B to save + +Basically the emulated keys you have are what I mapped the buttons to, +I have a virtual keyboard like the GP32 one (left/right on the stick to pick chars) to add in at some point ;-) + +CONTROLLER MAPPING: + +NOTE: The controller mappings have recently changed somewhat so please review the new setup. +This is subject to change; it still does not ‘feel’ quite right. + +Mouse Emulation: + +Stick: Move Pointer +Stick Click: ‘light’ Left Click +B: Left click +X: Right click + +Keyboard Emulation: + +Start: Return +Select: Escape +Y: Space Bar (Pause) +Right Trigger: Game Menu (Save, Load, Quit etc.) +Volume Buttons: Increase and Decrease volume (5% per press) + +Fancy button combos: + +NOTE: To use button combos press and hold the Left Trigger then... + +Volume Buttons: Increase and Decrease subtitle speed (In SCUMM games) +Right Trigger: 0 (For skipping the copy protection in Monkey Island 2) +Select: Exit ScummVM completely +(More to add, ideas please) + +KNOWN ISSUES: + +Possible random crash (well SegFault). I have had this happen twice and have not tracked down the cause. +It happens very infrequently, both times it was in the DOTT CD intro. Saving often is never a bad idea anyhow. + +Volume level changes can be a little inconsistent at times. + +MAJOR TODOS: + +Fix save support when using the Sky engine (Beneath a Steel Sky) - You CAN'T save at the moment but auto save works. +Look into inconsistencies with Simon engine and map Y key to a button combination to allow clean quitting (Simon 1/2). +Add splash-screen and pre-ScummVM config menu (CPU speed, LCD timings etc.) - Partly done. +Fix TV out, maybe make it an option in the pre-ScummVM config menu. +Any help appreciated :). + +SOURCE: + +Port source is available on request. Note this is development code (and VERY messy). + +John Willis \ No newline at end of file diff --git a/backends/platform/gp2x/build/build.sh b/backends/platform/gp2x/build/build.sh new file mode 100644 index 0000000000..55395cb73c --- /dev/null +++ b/backends/platform/gp2x/build/build.sh @@ -0,0 +1,19 @@ +#!/bin/bash + +echo Quick script to make building all the time less painful. + +# Set the paths up here to support the build. + +export PATH=/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/arm-open2x-linux/bin:$PATH +export PATH=/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/bin:$PATH +export CXX=arm-open2x-linux-g++ +export CC=arm-open2x-linux-gcc +export CXXFLAGS=-march=armv4t +export LDFLAGS=-static + +cd ../../../.. + +echo Building ScummVM for GP2X. +make + +echo Build for GP2X - SDL - complete - Please check build logs. diff --git a/backends/platform/gp2x/build/bundle.sh b/backends/platform/gp2x/build/bundle.sh new file mode 100644 index 0000000000..93efa63a83 --- /dev/null +++ b/backends/platform/gp2x/build/bundle.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +echo Quick script to make building a distribution of the GP2X port more consistent. + +PATH=/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/arm-open2x-linux/bin:$PATH +PATH=/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/bin:$PATH +export CXX=arm-open2x-linux-g++ +export CXXFLAGS=-march=armv4t +export CPPFLAGS=-I/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/include +export LDFLAGS=-L/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/lib + +echo Collecting files. +mkdir "scummvm-gp2x-`date '+%Y-%m-%d'`" + +cp ./scummvm.png ./scummvm-gp2x-`date '+%Y-%m-%d'`/ +cp ./README-GP2X.html ./scummvm-gp2x-`date '+%Y-%m-%d'`/ +cp ./README-GP2X ./scummvm-gp2x-`date '+%Y-%m-%d'`/ +cp ../../../../scummvm.gpe ./scummvm-gp2x-`date '+%Y-%m-%d'`/ +cp ../../../../AUTHORS ./scummvm-gp2x-`date '+%Y-%m-%d'`/ +cp ../../../../README ./scummvm-gp2x-`date '+%Y-%m-%d'`/ +cp ../../../../COPYING ./scummvm-gp2x-`date '+%Y-%m-%d'`/ +cp ../../../../gui/themes/modern.ini ./scummvm-gp2x-`date '+%Y-%m-%d'`/ +cp ../../../../gui/themes/modern.zip ./scummvm-gp2x-`date '+%Y-%m-%d'`/ + + +echo Making Stripped GPE. +arm-open2x-linux-strip ./scummvm-gp2x-`date '+%Y-%m-%d'`/scummvm.gpe + +echo Building ZIP bundle. +echo You should have a "scummvm-gp2x-`date '+%Y-%m-%d'`.zip" for the GP2X port ready to go. \ No newline at end of file diff --git a/backends/platform/gp2x/build/clean.sh b/backends/platform/gp2x/build/clean.sh new file mode 100644 index 0000000000..c603d95f83 --- /dev/null +++ b/backends/platform/gp2x/build/clean.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +echo Quick script to make building all the time less painful. + +# Set the paths up here to support the build. + +export PATH=/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/arm-open2x-linux/bin:$PATH +export PATH=/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/bin:$PATH +export CXX=arm-open2x-linux-g++ +export CC=arm-open2x-linux-gcc +export CXXFLAGS=-march=armv4t +export LDFLAGS=-static + +cd ../../../.. + +echo Cleaning ScummVM for GP2X. +make clean diff --git a/backends/platform/gp2x/build/config.sh b/backends/platform/gp2x/build/config.sh new file mode 100644 index 0000000000..b1d23b03fc --- /dev/null +++ b/backends/platform/gp2x/build/config.sh @@ -0,0 +1,22 @@ +#!/bin/bash + +echo Quick script to make running configure all the time less painful +echo and let all the build work be done from the backend/build folder. + +# Set the paths up here to generate the config. + +PATH=/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/arm-open2x-linux/bin:$PATH +PATH=/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/bin:$PATH + +# Export the tool names for cross-compiling +export CXX=arm-open2x-linux-g++ +export CXXFLAGS=-march=armv4t +export CPPFLAGS=-I/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/include +export LDFLAGS=-L/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/lib +export DEFINES=-DNDEBUG + +# Edit the configure line to suit. +cd ../../../.. +./configure --backend=gp2x --disable-mt32emu --host=gp2x --disable-mpeg2 --disable-flac --disable-nasm --disable-hq-scalers --with-sdl-prefix=/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux/bin --enable-tremor --with-tremor-prefix=/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux --enable-zlib --with-zlib-prefix=/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux --enable-mad --with-mad-prefix=/tools/open2x_gcc/gcc-4.0.2-glibc-2.3.5/arm-open2x-linux + +echo Generating config for GP2X complete. Check for errors. \ No newline at end of file diff --git a/backends/platform/gp2x/build/scummvm.png b/backends/platform/gp2x/build/scummvm.png new file mode 100644 index 0000000000..ede14b07e7 Binary files /dev/null and b/backends/platform/gp2x/build/scummvm.png differ diff --git a/backends/platform/gp2x/events.cpp b/backends/platform/gp2x/events.cpp new file mode 100644 index 0000000000..f3d5ef0d58 --- /dev/null +++ b/backends/platform/gp2x/events.cpp @@ -0,0 +1,657 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2005-2006 John Willis (Portions of the GP2X Backend) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +/* + * GP2X: Event Handling. + * + */ + +#include "backends/platform/gp2x/gp2x-common.h" +#include "backends/platform/gp2x/gp2x-hw.h" +#include "common/util.h" + +// FIXME move joystick defines out and replace with confile file options +// we should really allow users to map any key to a joystick button +#define JOY_DEADZONE 2200 + +// #define JOY_INVERT_Y +#define JOY_XAXIS 0 +#define JOY_YAXIS 1 + +// GP2X Stick Buttons (Note: The Stick is read as a set of buttons not a HAT type of setup). +#define JOY_BUT_LMOUSE 0x0D +#define JOY_BUT_RMOUSE 0x0E + +#define JOY_BUT_RETURN 0x08 +#define JOY_BUT_ESCAPE 0x09 +#define JOY_BUT_F5 0x0B +#define JOY_BUT_SPACE 0x0F +#define JOY_BUT_TALKUP 0x10 +#define JOY_BUT_TALKDN 0x11 +#define JOY_BUT_ZERO 0x12 + +#define JOY_BUT_COMB 0x0A +#define JOY_BUT_EXIT 0x12 +#define JOY_BUT_PERIOD 0x0C + + +//TODO: Quick hack 101 ;-) Clean this up, +#define TRUE 1 +#define FALSE 0 + +static int mapKey(SDLKey key, SDLMod mod, Uint16 unicode) +{ + if (key >= SDLK_F1 && key <= SDLK_F9) { + return key - SDLK_F1 + 315; + } else if (key >= SDLK_KP0 && key <= SDLK_KP9) { + return key - SDLK_KP0 + '0'; + } else if (key >= SDLK_UP && key <= SDLK_PAGEDOWN) { + return key; + } else if (unicode) { + return unicode; + } else if (key >= 'a' && key <= 'z' && mod & KMOD_SHIFT) { + return key & ~0x20; + } else if (key >= SDLK_NUMLOCK && key <= SDLK_EURO) { + return 0; + } + return key; +} + +void OSystem_GP2X::fillMouseEvent(Event &event, int x, int y) { + event.mouse.x = x; + event.mouse.y = y; + + // Update the "keyboard mouse" coords + _km.x = x; + _km.y = y; + + // Adjust for the screen scaling + if (!_overlayVisible) { + event.mouse.x /= _scaleFactor; + event.mouse.y /= _scaleFactor; + if (_adjustAspectRatio) + event.mouse.y = aspect2Real(event.mouse.y); + } +} + +void OSystem_GP2X::handleKbdMouse() { + uint32 curTime = getMillis(); + if (curTime >= _km.last_time + _km.delay_time) { + _km.last_time = curTime; + if (_km.x_down_count == 1) { + _km.x_down_time = curTime; + _km.x_down_count = 2; + } + if (_km.y_down_count == 1) { + _km.y_down_time = curTime; + _km.y_down_count = 2; + } + + if (_km.x_vel || _km.y_vel) { + if (_km.x_down_count) { + if (curTime > _km.x_down_time + _km.delay_time * 12) { + if (_km.x_vel > 0) + _km.x_vel++; + else + _km.x_vel--; + } else if (curTime > _km.x_down_time + _km.delay_time * 8) { + if (_km.x_vel > 0) + _km.x_vel = 5; + else + _km.x_vel = -5; + } + } + if (_km.y_down_count) { + if (curTime > _km.y_down_time + _km.delay_time * 12) { + if (_km.y_vel > 0) + _km.y_vel++; + else + _km.y_vel--; + } else if (curTime > _km.y_down_time + _km.delay_time * 8) { + if (_km.y_vel > 0) + _km.y_vel = 5; + else + _km.y_vel = -5; + } + } + + _km.x += _km.x_vel; + _km.y += _km.y_vel; + + if (_km.x < 0) { + _km.x = 0; + _km.x_vel = -1; + _km.x_down_count = 1; + } else if (_km.x > _km.x_max) { + _km.x = _km.x_max; + _km.x_vel = 1; + _km.x_down_count = 1; + } + + if (_km.y < 0) { + _km.y = 0; + _km.y_vel = -1; + _km.y_down_count = 1; + } else if (_km.y > _km.y_max) { + _km.y = _km.y_max; + _km.y_vel = 1; + _km.y_down_count = 1; + } + + SDL_WarpMouse(_km.x, _km.y); + } + } +} + +static byte SDLModToOSystemKeyFlags(SDLMod mod) { + byte b = 0; +#ifdef LINUPY + // Yopy has no ALT key, steal the SHIFT key + // (which isn't used much anyway) + if (mod & KMOD_SHIFT) + b |= OSystem::KBD_ALT; +#else + if (mod & KMOD_SHIFT) + b |= OSystem::KBD_SHIFT; + if (mod & KMOD_ALT) + b |= OSystem::KBD_ALT; +#endif + if (mod & KMOD_CTRL) + b |= OSystem::KBD_CTRL; + + return b; +} + +void OSystem_GP2X::moveStick() { + bool stickBtn[32]; + + memcpy(stickBtn, _stickBtn, sizeof(stickBtn)); + + if((stickBtn[0])||(stickBtn[2])||(stickBtn[4])||(stickBtn[6])) + stickBtn[1] = stickBtn[3] = stickBtn[5] = stickBtn[7] = 0; + + if((stickBtn[1])||(stickBtn[2])||(stickBtn[3])){ + if(_km.x_down_count!=2){ + _km.x_vel = -1; + _km.x_down_count = 1; + }else + _km.x_vel = -4; + } else if((stickBtn[5])||(stickBtn[6])||(stickBtn[7])){ + if(_km.x_down_count!=2){ + _km.x_vel = 1; + _km.x_down_count = 1; + }else + _km.x_vel = 4; + } + else{ + _km.x_vel = 0; + _km.x_down_count = 0; + } + + + if((stickBtn[0])||(stickBtn[1])||(stickBtn[7])){ + if(_km.y_down_count!=2){ + _km.y_vel = -1; + _km.y_down_count = 1; + }else + _km.y_vel = -4; + } else if((stickBtn[3])||(stickBtn[4])||(stickBtn[5])){ + if(_km.y_down_count!=2){ + _km.y_vel = 1; + _km.y_down_count = 1; + }else + _km.y_vel = 4; + } + else{ + _km.y_vel = 0; + _km.y_down_count = 0; + } +} + + //Quick default button states for modifier. + + //int GP2X_BUTTON_STATE_UP = FALSE; + //int GP2X_BUTTON_STATE_DOWN = FALSE; + //int GP2X_BUTTON_STATE_LEFT = FALSE; + //int GP2X_BUTTON_STATE_RIGHT = FALSE; + //int GP2X_BUTTON_STATE_UPLEFT = FALSE; + //int GP2X_BUTTON_STATE_UPRIGHT = FALSE; + //int GP2X_BUTTON_STATE_DOWNLEFT = FALSE; + //int GP2X_BUTTON_STATE_DOWNRIGHT = FALSE; + //int GP2X_BUTTON_STATE_CLICK = FALSE; + //int GP2X_BUTTON_STATE_A = FALSE; + //int GP2X_BUTTON_STATE_B = FALSE; + //int GP2X_BUTTON_STATE_Y = FALSE; + //int GP2X_BUTTON_STATE_X = FALSE; + int GP2X_BUTTON_STATE_L = FALSE; + //int GP2X_BUTTON_STATE_R = FALSE; + //int GP2X_BUTTON_STATE_START = FALSE; + //int GP2X_BUTTON_STATE_SELECT = FALSE; + //int GP2X_BUTTON_STATE_VOLUP = FALSE; + //int GP2X_BUTTON_STATE_VOLDOWN = FALSE; + +bool OSystem_GP2X::pollEvent(Event &event) { + SDL_Event ev; + int axis; + byte b = 0; + + handleKbdMouse(); + + // If the screen mode changed, send an EVENT_SCREEN_CHANGED + if (_modeChanged) { + _modeChanged = false; + event.type = EVENT_SCREEN_CHANGED; + _screenChangeCount++; + return true; + } + + // GP2X Input mappings. + + /* + Single Button + + Movement: + + GP2X_BUTTON_UP Cursor Up + GP2X_BUTTON_DOWN Cursor Down + GP2X_BUTTON_LEFT Cursor Left + GP2X_BUTTON_RIGHT Cursor Right + + TODO: Add extra directions to cursor mappings. + + GP2X_BUTTON_UPLEFT Cursor Up Left + GP2X_BUTTON_UPRIGHT Cursor Up Right + GP2X_BUTTON_DOWNLEFT Cursor Down Left + GP2X_BUTTON_DOWNRIGHT Cursor Down Right + + Button Emulation: + + GP2X_BUTTON_CLICK Left Mouse Click + GP2X_BUTTON_A . (Period) + GP2X_BUTTON_B Left Mouse Click + GP2X_BUTTON_Y Space Bar + GP2X_BUTTON_X Right Mouse Click + GP2X_BUTTON_L Combo Modifier (Left Trigger) + GP2X_BUTTON_R F5 (Right Trigger) + GP2X_BUTTON_START Return + GP2X_BUTTON_SELECT Escape + GP2X_BUTTON_VOLUP /dev/mixer Global Volume Up + GP2X_BUTTON_VOLDOWN /dev/mixer Global Volume Down + + Combos: + + GP2X_BUTTON_VOLUP & GP2X_BUTTON_VOLDOWN 0 (For Monkey 2 CP) + GP2X_BUTTON_L & GP2X_BUTTON_SELECT EVENT_QUIT (Calls Sync() to make sure SD is flushed) + GP2X_BUTTON_L & GP2X_BUTTON_Y Toggles setZoomOnMouse() for larger then 320*240 games to scale to the point + raduis. + */ + + while(SDL_PollEvent(&ev)) { + + switch(ev.type) { + case SDL_KEYDOWN:{ + b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState()); + + // Alt-Return and Alt-Enter toggle full screen mode + if (b == KBD_ALT && (ev.key.keysym.sym == SDLK_RETURN + || ev.key.keysym.sym == SDLK_KP_ENTER)) { + setFullscreenMode(!_fullscreen); + break; + } + + // Alt-S: Create a screenshot + if (b == KBD_ALT && ev.key.keysym.sym == 's') { + char filename[20]; + + for (int n = 0;; n++) { + SDL_RWops *file; + + sprintf(filename, "scummvm%05d.bmp", n); + file = SDL_RWFromFile(filename, "r"); + if (!file) + break; + SDL_RWclose(file); + } + if (saveScreenshot(filename)) + printf("Saved '%s'\n", filename); + else + printf("Could not save screenshot!\n"); + break; + } + + // Ctrl-m toggles mouse capture + //if (b == KBD_CTRL && ev.key.keysym.sym == 'm') { + // toggleMouseGrab(); + // break; + //} + +//#ifdef MACOSX +// // On Macintosh', Cmd-Q quits +// if ((ev.key.keysym.mod & KMOD_META) && ev.key.keysym.sym == 'q') { +// event.type = EVENT_QUIT; +// return true; +// } +//#elif defined(UNIX) +// // On other unices, Control-Q quits +// if ((ev.key.keysym.mod & KMOD_CTRL) && ev.key.keysym.sym == 'q') { +// event.type = EVENT_QUIT; +// return true; +// } +//#else +// // Ctrl-z and Alt-X quit +// if ((b == KBD_CTRL && ev.key.keysym.sym == 'z') || (b == KBD_ALT && ev.key.keysym.sym == 'x')) { +// event.type = EVENT_QUIT; +// return true; +// } +//#endif +// +// // Ctrl-Alt- will change the GFX mode +// if ((b & (KBD_CTRL|KBD_ALT)) == (KBD_CTRL|KBD_ALT)) { +// +// handleScalerHotkeys(ev.key); +// break; +// } + const bool event_complete = remapKey(ev,event); + + if (event_complete) + return true; + + event.type = EVENT_KEYDOWN; + event.kbd.keycode = ev.key.keysym.sym; + event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode); + + return true; + } + case SDL_KEYUP: + { + const bool event_complete = remapKey(ev,event); + + if (event_complete) + return true; + + event.type = EVENT_KEYUP; + event.kbd.keycode = ev.key.keysym.sym; + event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode); + b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState()); + + // Ctrl-Alt- will change the GFX mode + if ((b & (KBD_CTRL|KBD_ALT)) == (KBD_CTRL|KBD_ALT)) { + // Swallow these key up events + break; + } + + return true; + } + case SDL_MOUSEMOTION: + event.type = EVENT_MOUSEMOVE; + fillMouseEvent(event, ev.motion.x, ev.motion.y); + + setMousePos(event.mouse.x, event.mouse.y); + return true; + + case SDL_MOUSEBUTTONDOWN: + if (ev.button.button == SDL_BUTTON_LEFT) + event.type = EVENT_LBUTTONDOWN; + else if (ev.button.button == SDL_BUTTON_RIGHT) + event.type = EVENT_RBUTTONDOWN; +#if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN) + else if (ev.button.button == SDL_BUTTON_WHEELUP) + event.type = EVENT_WHEELUP; + else if (ev.button.button == SDL_BUTTON_WHEELDOWN) + event.type = EVENT_WHEELDOWN; +#endif + else + break; + + fillMouseEvent(event, ev.button.x, ev.button.y); + + return true; + + case SDL_MOUSEBUTTONUP: + if (ev.button.button == SDL_BUTTON_LEFT) + event.type = EVENT_LBUTTONUP; + else if (ev.button.button == SDL_BUTTON_RIGHT) + event.type = EVENT_RBUTTONUP; + else + break; + fillMouseEvent(event, ev.button.x, ev.button.y); + + return true; + + // GP2X Button mapings. Main code + + case SDL_JOYBUTTONDOWN: + _stickBtn[ev.jbutton.button] = 1; + if (ev.jbutton.button == JOY_BUT_LMOUSE) { + event.type = EVENT_LBUTTONDOWN; + fillMouseEvent(event, _km.x, _km.y); + } else if (ev.jbutton.button == GP2X_BUTTON_CLICK) { + event.type = EVENT_LBUTTONDOWN; + fillMouseEvent(event, _km.x, _km.y); + } else if (ev.jbutton.button == JOY_BUT_RMOUSE) { + event.type = EVENT_RBUTTONDOWN; + fillMouseEvent(event, _km.x, _km.y); + } else if (_stickBtn[JOY_BUT_COMB] && (ev.jbutton.button == JOY_BUT_EXIT)) { + event.type = EVENT_QUIT; + } else if (ev.jbutton.button < 8) { + moveStick(); + event.type = EVENT_MOUSEMOVE; + fillMouseEvent(event, _km.x, _km.y); + } else { + event.type = EVENT_KEYDOWN; + event.kbd.flags = 0; + switch (ev.jbutton.button) { + case GP2X_BUTTON_L: + GP2X_BUTTON_STATE_L = TRUE; + break; + case GP2X_BUTTON_R: + if (GP2X_BUTTON_STATE_L == TRUE) { + event.kbd.keycode = SDLK_0; + event.kbd.ascii = mapKey(SDLK_0, ev.key.keysym.mod, 0); + } else { + event.kbd.keycode = SDLK_F5; + event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0); + } + break; + case GP2X_BUTTON_SELECT: + if (GP2X_BUTTON_STATE_L == TRUE) { + event.type = EVENT_QUIT; + } else { + event.kbd.keycode = SDLK_ESCAPE; + event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0); + } + break; + case GP2X_BUTTON_A: + event.kbd.keycode = SDLK_PERIOD; + event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0); + break; + case GP2X_BUTTON_Y: + if (GP2X_BUTTON_STATE_L == TRUE) { + setZoomOnMouse(); + } else { + event.kbd.keycode = SDLK_SPACE; + event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0); + } + break; + case JOY_BUT_RETURN: + event.kbd.keycode = SDLK_RETURN; + event.kbd.ascii = mapKey(SDLK_RETURN, ev.key.keysym.mod, 0); + break; + case JOY_BUT_ZERO: + event.kbd.keycode = SDLK_0; + event.kbd.ascii = mapKey(SDLK_0, ev.key.keysym.mod, 0); + break; + + //case GP2X_BUTTON_R: + // if ((ev.jbutton.button == GP2X_BUTTON_L) && (ev.jbutton.button == GP2X_BUTTON_R)) { + // displayMessageOnOSD("Exiting ScummVM"); + // //Sync(); + // event.type = EVENT_QUIT; + // break; + // } else if ((ev.jbutton.button == GP2X_BUTTON_L) && (ev.jbutton.button != GP2X_BUTTON_R)) { + // displayMessageOnOSD("Left Trigger Pressed"); + // break; + // } else if ((ev.jbutton.button == GP2X_BUTTON_R) && (ev.jbutton.button != GP2X_BUTTON_L)) { + // event.kbd.keycode = SDLK_F5; + // event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0); + // break; + // } else { + // break; + // } + // break; + case GP2X_BUTTON_VOLUP: + if (GP2X_BUTTON_STATE_L == TRUE) { + displayMessageOnOSD("Setting CPU Speed at 230MHz"); + GP2X_setCpuspeed(200); + //event.kbd.keycode = SDLK_PLUS; + //event.kbd.ascii = mapKey(SDLK_PLUS, ev.key.keysym.mod, 0); + } else { + GP2X_mixer_move_volume(1); + displayMessageOnOSD("Increasing Volume"); + } + break; + case GP2X_BUTTON_VOLDOWN: + if (GP2X_BUTTON_STATE_L == TRUE) { + displayMessageOnOSD("Setting CPU Speed at 60MHz"); + GP2X_setCpuspeed(60); + //event.kbd.keycode = SDLK_MINUS; + //event.kbd.ascii = mapKey(SDLK_MINUS, ev.key.keysym.mod, 0); + } else { + GP2X_mixer_move_volume(0); + displayMessageOnOSD("Decreasing Volume"); + } + break; + } + } + return true; + + case SDL_JOYBUTTONUP: + _stickBtn[ev.jbutton.button] = 0; + if (ev.jbutton.button == JOY_BUT_LMOUSE) { + event.type = EVENT_LBUTTONUP; + fillMouseEvent(event, _km.x, _km.y); + } else if (ev.jbutton.button == JOY_BUT_RMOUSE) { + event.type = EVENT_RBUTTONUP; + fillMouseEvent(event, _km.x, _km.y); + } else if (ev.jbutton.button < 8) { + moveStick(); + event.type = EVENT_MOUSEMOVE; + fillMouseEvent(event, _km.x, _km.y); + } else { + event.type = EVENT_KEYUP; + event.kbd.flags = 0; + switch (ev.jbutton.button) { + case GP2X_BUTTON_SELECT: + event.kbd.keycode = SDLK_ESCAPE; + event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0); + break; + case GP2X_BUTTON_A: + event.kbd.keycode = SDLK_PERIOD; + event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0); + break; + case GP2X_BUTTON_Y: +// event.kbd.keycode = SDLK_SPACE; +// event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0); + break; + case GP2X_BUTTON_START: + event.kbd.keycode = SDLK_RETURN; + event.kbd.ascii = mapKey(SDLK_RETURN, ev.key.keysym.mod, 0); + break; + case GP2X_BUTTON_L: + GP2X_BUTTON_STATE_L = FALSE; + break; + case GP2X_BUTTON_R: + event.kbd.keycode = SDLK_F5; + event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0); + break; + case GP2X_BUTTON_VOLUP: + break; + case GP2X_BUTTON_VOLDOWN: + break; + } + } + return true; + + case SDL_JOYAXISMOTION: + axis = ev.jaxis.value; + if ( axis > JOY_DEADZONE) { + axis -= JOY_DEADZONE; + event.type = EVENT_MOUSEMOVE; + } else if ( axis < -JOY_DEADZONE ) { + axis += JOY_DEADZONE; + event.type = EVENT_MOUSEMOVE; + } else + axis = 0; + + if ( ev.jaxis.axis == JOY_XAXIS) { +#ifdef JOY_ANALOG + _km.x_vel = axis/2000; + _km.x_down_count = 0; +#else + if (axis != 0) { + _km.x_vel = (axis > 0) ? 1:-1; + _km.x_down_count = 1; + } else { + _km.x_vel = 0; + _km.x_down_count = 0; + } +#endif + + } else if (ev.jaxis.axis == JOY_YAXIS) { +#ifndef JOY_INVERT_Y + axis = -axis; +#endif +#ifdef JOY_ANALOG + _km.y_vel = -axis / 2000; + _km.y_down_count = 0; +#else + if (axis != 0) { + _km.y_vel = (-axis > 0) ? 1: -1; + _km.y_down_count = 1; + } else { + _km.y_vel = 0; + _km.y_down_count = 0; + } +#endif + } + + fillMouseEvent(event, _km.x, _km.y); + + return true; + + case SDL_VIDEOEXPOSE: + _forceFull = true; + break; + + case SDL_QUIT: + event.type = EVENT_QUIT; + return true; + } + } + return false; +} + +bool OSystem_GP2X::remapKey(SDL_Event &ev,Event &event) { + return false; +} + diff --git a/backends/platform/gp2x/gp2x-common.h b/backends/platform/gp2x/gp2x-common.h new file mode 100644 index 0000000000..d768e1c4d8 --- /dev/null +++ b/backends/platform/gp2x/gp2x-common.h @@ -0,0 +1,402 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2005-2006 John Willis (Portions of the GP2X Backend) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef GP2X_COMMON_H +#define GP2X_COMMON_H + +#define __GP2X__ +#define USE_OSD + +#include "common/stdafx.h" +#include "common/scummsys.h" +#include "common/system.h" +#include "graphics/scaler.h" +#include "backends/intern.h" + +#include +#include + +//#define DISABLE_SCALERS + +enum { + GFX_NORMAL = 0, + GFX_DOUBLESIZE = 1, + GFX_TRIPLESIZE = 2, + GFX_2XSAI = 3, + GFX_SUPER2XSAI = 4, + GFX_SUPEREAGLE = 5, + GFX_ADVMAME2X = 6, + GFX_ADVMAME3X = 7, + GFX_HQ2X = 8, + GFX_HQ3X = 9, + GFX_TV2X = 10, + GFX_DOTMATRIX = 11 +}; + + +class OSystem_GP2X : public OSystem { +public: + OSystem_GP2X(); + virtual ~OSystem_GP2X(); + + virtual void initBackend(); + + void beginGFXTransaction(void); + void endGFXTransaction(void); + + // Set the size of the video bitmap. + // Typically, 320x200 + void initSize(uint w, uint h); + int getScreenChangeID() const { return _screenChangeCount; } + + // Set colors of the palette + void setPalette(const byte *colors, uint start, uint num); + + // Get colors of the palette + void grabPalette(byte *colors, uint start, uint num); + + // Draw a bitmap to screen. + // The screen will not be updated to reflect the new bitmap + void copyRectToScreen(const byte *src, int pitch, int x, int y, int w, int h); + + // Copies the screen to a buffer + bool grabRawScreen(Graphics::Surface *surf); + + // Clear the screen + void clearScreen(); + + // Update the dirty areas of the screen + void updateScreen(); + + // Either show or hide the mouse cursor + bool showMouse(bool visible); + + // Warp the mouse cursor. Where set_mouse_pos() only informs the + // backend of the mouse cursor's current position, this function + // actually moves the cursor to the specified position. + void warpMouse(int x, int y); + + // Set the bitmap that's used when drawing the cursor. + void setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor, int cursorTargetScale); + + // Set colors of cursor palette + void setCursorPalette(const byte *colors, uint start, uint num); + + // Disables or enables cursor palette + void disableCursorPalette(bool disable) { + _cursorPaletteDisabled = disable; + blitCursor(); + }; + + // Shaking is used in SCUMM. Set current shake position. + void setShakePos(int shake_pos); + + // Get the number of milliseconds since the program was started. + uint32 getMillis(); + + // Delay for a specified amount of milliseconds + void delayMillis(uint msecs); + + // Get the next event. + // Returns true if an event was retrieved. + virtual bool pollEvent(Event &event); // overloaded by CE backend + + // Set function that generates samples + virtual bool setSoundCallback(SoundProc proc, void *param); // overloaded by CE backend + + void clearSoundCallback(); + + // Poll CD status + // Returns true if cd audio is playing + bool pollCD(); + + // Play CD audio track + void playCD(int track, int num_loops, int start_frame, int duration); + + // Stop CD audio track + void stopCD(); + + // Update CD audio status + void updateCD(); + + // Quit + virtual void quit(); // overloaded by CE backend + + + // Add a callback timer + void setTimerCallback(TimerProc callback, int timer); + + // Mutex handling + MutexRef createMutex(); + void lockMutex(MutexRef mutex); + void unlockMutex(MutexRef mutex); + void deleteMutex(MutexRef mutex); + + // Overlay + void showOverlay(); + void hideOverlay(); + void clearOverlay(); + void grabOverlay(OverlayColor *buf, int pitch); + void copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h); // WinCE FIXME + int16 getHeight(); + int16 getWidth(); + int16 getOverlayHeight() { return _overlayHeight; } + int16 getOverlayWidth() { return _overlayWidth; } + + // Methods that convert RGB to/from colors suitable for the overlay. + OverlayColor RGBToColor(uint8 r, uint8 g, uint8 b); + void colorToRGB(OverlayColor color, uint8 &r, uint8 &g, uint8 &b); + + + virtual const GraphicsMode *getSupportedGraphicsModes() const; + virtual int getDefaultGraphicsMode() const; + virtual bool setGraphicsMode(int mode); + virtual int getGraphicsMode() const; + + //virtual void setWindowCaption(const char *caption); + virtual bool openCD(int drive); + virtual int getOutputSampleRate() const; + + virtual bool hasFeature(Feature f); + virtual void setFeatureState(Feature f, bool enable); + virtual bool getFeatureState(Feature f); + + void displayMessageOnOSD(const char *msg); + +protected: + bool _inited; + + SDL_Surface *_osdSurface; + Uint8 _osdAlpha; // Transparency level of the OSD + uint32 _osdFadeStartTime; // When to start the fade out + enum { + kOSDFadeOutDelay = 2 * 1000, // Delay before the OSD is faded out (in milliseconds) + kOSDFadeOutDuration = 500, // Duration of the OSD fade out (in milliseconds) + kOSDColorKey = 1, + kOSDInitialAlpha = 80 // Initial alpha level, in percent + }; + + // hardware screen + SDL_Surface *_hwscreen; + + // unseen game screen + SDL_Surface *_screen; + int _screenWidth, _screenHeight; + + // temporary screen (for scalers) + SDL_Surface *_tmpscreen; + SDL_Surface *_tmpscreen2; + + // overlay + SDL_Surface *_overlayscreen; + int _overlayWidth, _overlayHeight; + bool _overlayVisible; + + // Audio + int _samplesPerSec; + + // CD Audio + SDL_CD *_cdrom; + int _cdTrack, _cdNumLoops, _cdStartFrame, _cdDuration; + uint32 _cdEndTime, _cdStopTime; + + enum { + DF_WANT_RECT_OPTIM = 1 << 0, + DF_UPDATE_EXPAND_1_PIXEL = 1 << 1 + }; + + enum { + kTransactionNone = 0, + kTransactionCommit = 1, + kTransactionActive = 2 + }; + + struct TransactionDetails { + int mode; + bool modeChanged; + int w; + int h; + bool sizeChanged; + bool fs; + bool fsChanged; + bool ar; + bool arChanged; + bool needHotswap; + bool needUpdatescreen; + bool needUnload; + bool needToggle; + bool normal1xScaler; + }; + TransactionDetails _transactionDetails; + + /** Force full redraw on next updateScreen */ + bool _forceFull; + ScalerProc *_scalerProc; + int _scalerType; + int _scaleFactor; + int _mode; + int _transactionMode; + bool _fullscreen; + + /** Current video mode flags (see DF_* constants) */ + uint32 _modeFlags; + bool _modeChanged; + int _screenChangeCount; + + /** True if aspect ratio correction is enabled. */ + bool _adjustAspectRatio; + + /** True if zoom on mouse is enabled. (only set by > 240 high games) */ + bool _adjustZoomOnMouse; + //_adjustZoomOnMouse = false; + + enum { + NUM_DIRTY_RECT = 100, + + MAX_MOUSE_W = 80, + MAX_MOUSE_H = 80, + MAX_SCALING = 3 + }; + + // Dirty rect management + SDL_Rect _dirtyRectList[NUM_DIRTY_RECT]; + int _numDirtyRects; + uint32 *_dirtyChecksums; + bool _cksumValid; + int _cksumNum; + + // Keyboard mouse emulation. Disabled by fingolfin 2004-12-18. + // I am keeping the rest of the code in for now, since the joystick + // code (or rather, "hack") uses it, too. + struct KbdMouse { + int16 x, y, x_vel, y_vel, x_max, y_max, x_down_count, y_down_count; + uint32 last_time, delay_time, x_down_time, y_down_time; + }; + + struct MousePos { + // The mouse position, using either virtual (game) or real + // (overlay) coordinates. + int16 x, y; + + // The size and hotspot of the original cursor image. + int16 w, h; + int16 hotX, hotY; + + // The size and hotspot of the pre-scaled cursor image, in real + // coordinates. + int16 rW, rH; + int16 rHotX, rHotY; + + // The size and hotspot of the pre-scaled cursor image, in game + // coordinates. + int16 vW, vH; + int16 vHotX, vHotY; + + MousePos() : x(0), y(0), w(0), h(0), hotX(0), hotY(0), + rW(0), rH(0), rHotX(0), rHotY(0), vW(0), vH(0), + vHotX(0), vHotY(0) + { } + }; + + // mouse + KbdMouse _km; + bool _mouseVisible; + bool _mouseDrawn; + byte *_mouseData; + SDL_Rect _mouseBackup; + MousePos _mouseCurState; + //int16 _mouseHotspotX; + //int16 _mouseHotspotY; + byte _mouseKeyColor; + int _cursorTargetScale; + //bool _cursorHasOwnPalette; + bool _cursorPaletteDisabled; + SDL_Surface *_mouseOrigSurface; + SDL_Surface *_mouseSurface; + enum { + kMouseColorKey = 1 + }; + + // joystick + SDL_Joystick *_joystick; + bool _stickBtn[32]; + + // Shake mode + int _currentShakePos; + int _newShakePos; + + // Palette data + SDL_Color *_currentPalette; + uint _paletteDirtyStart, _paletteDirtyEnd; + + // Cursor palette data + SDL_Color *_cursorPalette; + + /** + * Mutex which prevents multiple threads from interfering with each other + * when accessing the screen. + */ + MutexRef _graphicsMutex; + + + void addDirtyRgnAuto(const byte *buf); + void makeChecksums(const byte *buf); + + virtual void addDirtyRect(int x, int y, int w, int h, bool realCoordinates = false); + + void drawMouse(); + virtual void undrawMouse(); + virtual void blitCursor(); + + /** Set the position of the virtual mouse cursor. */ + void setMousePos(int x, int y); + virtual void fillMouseEvent(Event &event, int x, int y); + //void toggleMouseGrab(); + + virtual void internUpdateScreen(); + + virtual void loadGFXMode(); + virtual void unloadGFXMode(); + virtual void hotswapGFXMode(); + + void setFullscreenMode(bool enable); + void setAspectRatioCorrection(bool enable); + + void setZoomOnMouse(); // GP2X: On > 240 high games zooms on the mouse + radius. + + virtual bool saveScreenshot(const char *filename); + + int effectiveScreenHeight() const { return (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor; } + + void setupIcon(); + void handleKbdMouse(); + + virtual bool remapKey(SDL_Event &ev, Event &event); + + void handleScalerHotkeys(const SDL_KeyboardEvent &key); + + void moveStick(); +}; + +#endif // GP2X_COMMON_H diff --git a/backends/platform/gp2x/gp2x-hw.cpp b/backends/platform/gp2x/gp2x-hw.cpp new file mode 100644 index 0000000000..e967b6df62 --- /dev/null +++ b/backends/platform/gp2x/gp2x-hw.cpp @@ -0,0 +1,248 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2005-2006 John Willis (Portions of the GP2X Backend) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +/* + * GP2X: Hardware Stuff. + * Thanks to Rlyeh, Snaff, Squidge, Hermes, PS2Reality and RobBrown + * for there help with us all getting to grips with this. + * + */ + +#include "gp2x-common.h" + +#include "gp2x-hw.h" + +// Linux includes to let us goof about with the system. +#include +#include +#include + +static unsigned long gp2x_dev[8]={0,0,0,0,0,0,0,0};//, gp2x_ticks_per_second; +static volatile unsigned short *gp2x_memregs; + +/* system registers */ +static struct +{ + unsigned short SYSCLKENREG,SYSCSETREG,FPLLVSETREG,DUALINT920,DUALINT940,DUALCTRL940; +} +system_reg; + +static unsigned short dispclockdiv; + +static volatile unsigned short *MEM_REG; + +#define SYS_CLK_FREQ 7372800 + +void GP2X_device_init() { + // Open devices + if(!gp2x_dev[0]) gp2x_dev[0] = open("/dev/mixer", O_RDWR); + if(!gp2x_dev[1]) gp2x_dev[1] = open("/dev/batt", O_RDONLY); + if(!gp2x_dev[2]) gp2x_dev[2] = open("/dev/mem", O_RDWR); +} + +void GP2X_device_deinit() { + // Close devices + if (gp2x_dev[0]) close(gp2x_dev[0]); + if (gp2x_dev[1]) close(gp2x_dev[1]); + if (gp2x_dev[2]) close(gp2x_dev[2]); + + MEM_REG[0x91c>>1]=system_reg.SYSCSETREG; + MEM_REG[0x910>>1]=system_reg.FPLLVSETREG; + MEM_REG[0x3B40>>1]=system_reg.DUALINT920; + MEM_REG[0x3B42>>1]=system_reg.DUALINT940; + MEM_REG[0x3B48>>1]=system_reg.DUALCTRL940; + MEM_REG[0x904>>1]=system_reg.SYSCLKENREG; + MEM_REG[0x924>>1]=dispclockdiv; +} + + +// Vairous mixer level fudges. +// TODO: Clean up and merge quick hacks. + +void GP2X_mixer_set_volume(int L /*0..100*/, int R /*0..100*/) { + + /* Set an arbitrary percentage value for the hardware mixer volume. + + Parameters: + L (0..100) - volume percentage for the left channel + R (0..100) - volume percentage for the right channel + + Note: + - A higher percentage than 100 will distort your sound. + */ + + unsigned char temp[4]; + + if (L < 0) L = 0; + if (L > GP2X_MAXVOL) L = GP2X_MAXVOL; + if (R < 0) R = 0; + if (R > GP2X_MAXVOL) R = GP2X_MAXVOL; + + temp[0]=(unsigned char)L; + temp[1]=(unsigned char)R; + temp[2]=temp[3]=0; + + //warning("GP2X_mixer_set_volume is about to set %d %d", L, R); + ioctl(gp2x_dev[0], SOUND_MIXER_WRITE_PCM, temp); +} + +int GP2X_mixer_get_volume() { + int vol; + ioctl(gp2x_dev[0], SOUND_MIXER_READ_PCM, &vol); + //warning("GP2X_mixer_get_volume returned %d %d", (int)((vol & 0xff)), (int)((vol >> 8) & 0xff)); + return (int)((vol & 0xff)); +} + +void GP2X_mixer_move_volume(int UpDown) { + // Raise volume 5% if 1 passed, lower 5% if 0. + int curvol, newvol; + ioctl(gp2x_dev[0], SOUND_MIXER_READ_PCM, &curvol); + curvol = ((int)((curvol & 0xff))); + newvol = ((int)((curvol & 0xff))); + //warning("GP2X_mixer_move_volume got current volume @ %d", curvol); + if (UpDown == 1) { + newvol = (curvol + 5); + } else if (UpDown == 0) { + newvol = (curvol - 5); + } + //warning("GP2X_mixer_move_volume is about to set volume @ %d", newvol); + GP2X_mixer_set_volume(newvol, newvol); + return; +} + +void GP2X_setCpuspeed(unsigned int mhz) +{ + set_FCLK(mhz); + set_DCLK_Div(0); + set_920_Div(0); +} + +void set_display_clock_div(unsigned div) +{ + div=((div & 63) | 64)<<8; + MEM_REG[0x924>>1]=(MEM_REG[0x924>>1] & ~(255<<8)) | div; +} + + +void set_FCLK(unsigned MHZ) +{ + unsigned v; + unsigned mdiv,pdiv=3,scale=0; + MHZ*=1000000; + mdiv=(MHZ*pdiv)/SYS_CLK_FREQ; + mdiv=((mdiv-8)<<8) & 0xff00; + pdiv=((pdiv-2)<<2) & 0xfc; + scale&=3; + v=mdiv | pdiv | scale; + MEM_REG[0x910>>1]=v; +} + + +void set_920_Div(unsigned short div) +{ + unsigned short v; + v = MEM_REG[0x91c>>1] & (~0x3); + MEM_REG[0x91c>>1] = (div & 0x7) | v; +} + + +void set_DCLK_Div( unsigned short div ) +{ + unsigned short v; + v = (unsigned short)( MEM_REG[0x91c>>1] & (~(0x7 << 6)) ); + MEM_REG[0x91c>>1] = ((div & 0x7) << 6) | v; +} + + +void Disable_940(void) +{ + MEM_REG[0x3B42>>1]; + MEM_REG[0x3B42>>1]=0; + MEM_REG[0x3B46>>1]=0xffff; + MEM_REG[0x3B48>>1]|= (1 << 7); + MEM_REG[0x904>>1]&=0xfffe; +} + +void gp2x_video_wait_vsync(void) +{ + MEM_REG[0x2846>>1]=(MEM_REG[0x2846>>1] | 0x20) & ~2; + while(!(MEM_REG[0x2846>>1] & 2)); +} + +//char GP2X_get_battery_level() { + // Returns string of level in English for use in displayMessageOnOSD() to show battery level. + // + //if (gp2x_dev[1] == -1) + //{ + // warning("Error occured getting voltage status"); + // return "Unable to read battery level."; + //} + // + //int i; + //int battval; + //unsigned short cbv; + //int v; + // + //battval = 0; + //for (i = 0; i < 1000; i ++) + //{ + // if (read (gp2x_dev[1], &cbv, 2) == 2) + // battval += cbv; + // if (gp2x_joystick_read() & GP2X_START) + // { + // needexit = 1; + // break; + // } + //} + //if (needexit) break; + // + //battval /= 1000; + + // Do a very rough translation + //if (battval > 1016) v = 37; + //else if (battval > 974) v = 33; + //else if (battval > 943) v = 32; + //else if (battval > 915) v = 31; + //else if (battval > 896) v = 30; + //else if (battval > 837) v = 29; + //else if (battval > 815) v = 28; + //else if (battval > 788) v = 27; + //else if (battval > 745) v = 26; + //else if (battval > 708) v = 25; + //else if (battval > 678) v = 24; + //else if (battval > 649) v = 23; + //else if (battval > 605) v = 22; + //else if (battval > 573) v = 21; + //else if (battval > 534) v = 20; + //else if (battval > 496) v = 19; + //else if (battval > 448) v = 18; + //else v = 17; + + //gp2x_printf (NULL, 0, 0, "Voltage: ~%d.%dV (%s)", v/10, v%10, v>26?"Battery Full" : v>24?"Battery Medium" : "Battery Empty"); + //gp2x_video_RGB_flip(0); + //} + //close (gp2x_dev[1]); + + //return "Voltage: ~%d.%dV (%s)", v/10, v%10, v>26?"Battery Full" : v>24?"Battery Medium" : "Battery Empty"; +//} diff --git a/backends/platform/gp2x/gp2x-hw.h b/backends/platform/gp2x/gp2x-hw.h new file mode 100644 index 0000000000..59593882b0 --- /dev/null +++ b/backends/platform/gp2x/gp2x-hw.h @@ -0,0 +1,74 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2005-2006 John Willis (Portions of the GP2X Backend) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +/* + * GP2X: Hardware Stuff. + * + */ + +#ifndef GP2X_HW_H +#define GP2X_HW_H + +//GP2X Main Joystick Mappings +//TODO: Use these more standard mappings over the custom ones. + +#define GP2X_BUTTON_UP (0) +#define GP2X_BUTTON_UPLEFT (1) +#define GP2X_BUTTON_LEFT (2) +#define GP2X_BUTTON_DOWNLEFT (3) +#define GP2X_BUTTON_DOWN (4) +#define GP2X_BUTTON_DOWNRIGHT (5) +#define GP2X_BUTTON_RIGHT (6) +#define GP2X_BUTTON_UPRIGHT (7) +#define GP2X_BUTTON_START (8) +#define GP2X_BUTTON_SELECT (9) +#define GP2X_BUTTON_L (10) +#define GP2X_BUTTON_R (11) +#define GP2X_BUTTON_A (12) +#define GP2X_BUTTON_B (13) +#define GP2X_BUTTON_X (14) +#define GP2X_BUTTON_Y (15) +#define GP2X_BUTTON_VOLUP (16) +#define GP2X_BUTTON_VOLDOWN (17) +#define GP2X_BUTTON_CLICK (18) + +#define GP2X_MAXVOL 100 // Highest level permitted by GP2X's mixer +#define SYS_CLK_FREQ 7372800 // Clock Frequency + +extern void GP2X_device_init(); +extern void GP2X_device_deinit(); +extern void GP2X_mixer_set_volume(int, int); +extern int GP2X_mixer_get_volume(); +extern void GP2X_mixer_move_volume(int); +extern void GP2X_setCpuspeed(unsigned int cpuspeed); + +extern void save_system_regs(void); /* save some registers */ +extern void set_display_clock_div(unsigned div); +extern void set_FCLK(unsigned MHZ); /* adjust the clock frequency (in Mhz units) */ +extern void set_920_Div(unsigned short div); /* 0 to 7 divider (freq=FCLK/(1+div)) */ +extern void set_DCLK_Div(unsigned short div); /* 0 to 7 divider (freq=FCLK/(1+div)) */ +extern void Disable_940(void); /* 940t down */ +extern void gp2x_video_wait_vsync(void); + +#endif //GP2X_HW_H diff --git a/backends/platform/gp2x/gp2x-mem.c b/backends/platform/gp2x/gp2x-mem.c new file mode 100644 index 0000000000..fa09c2c4bd --- /dev/null +++ b/backends/platform/gp2x/gp2x-mem.c @@ -0,0 +1,300 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2005-2006 John Willis (Portions of the GP2X Backend) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +/* + * GP2X: Memory tweaking stuff. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "gp2x-mem.h" + +void InitRam (void) +{ + if(!gp2x_dev) + { + gp2x_dev = open("/dev/mem", O_RDWR); + gp2x_ram = (unsigned short *)mmap(0, 0x10000, 3, 1, gp2x_dev, 0x03000000); + gp2x_memregs = (unsigned short *)mmap(0, 0x10000, 3, 1, gp2x_dev, 0xc0000000); + } +} + +void CloseRam (void) +{ + if(gp2x_dev) close(gp2x_dev); +} + +/* +****** [BEGIN] Squidge's MMU hack code ****** +*/ + +int myuname(char *buffer) +{ + asm volatile ("swi #0x90007a"); +} + +void DecodeCoarse (unsigned int indx, unsigned int sa) +{ + unsigned int cpt[256]; + unsigned int temp; + unsigned int i = 0; + unsigned int wb = 0; + + sa &= 0xfffffc00; + indx *= 1048576; + + //printf (" > %08X\n", sa); + //printf ("%d\n", + lseek (gp2x_dev, sa, SEEK_SET); + memset (cpt, 0, 256*4); + temp = read (gp2x_dev, cpt, 256*4); + //printf ("%d\n", temp); + if (temp != 256*4) + { + printf (" # Bad read\n"); + return; + } + + //printf ("%08X %08X %08X %08X\n", cpt[0], cpt[4], cpt[8], cpt[12]); + + for (i = 0; i < 256; i ++) + { + if (cpt[i]) + { + switch (cpt[i] & 3) + { + case 0: + //printf (" -- [%08X] Invalid --\n", cpt[i]); + break; + case 1: + /* + printf (" VA: %08X PA: %08X - %08X A: %d %d %d %d D: %d C: %d B: %d\n", indx, + cpt[i] & 0xFFFF0000, (cpt[i] & 0xFFFF0000) | 0xFFFF, + (cpt[i] >> 10) & 3, (cpt[i] >> 8) & 3, (cpt[i] >> 6) & 3, + (cpt[i] >> 4) & 3, dom, (cpt[i] >> 3) & 1, (cpt[i] >> 2) & 1); + */ + break; + case 2: + //a=((cpt[i] & 0xff000000)>>24); + /*printf (" VA: %08X PA: %08X - %08X A: %d %d %d %d D: %d C: %d B: %d\n", indx, + cpt[i] & 0xfffff000, (cpt[i] & 0xfffff000) | 0xFFF, + (cpt[i] >> 10) & 3, (cpt[i] >> 8) & 3, (cpt[i] >> 6) & 3, + (cpt[i] >> 4) & 3, dom, (cpt[i] >> 3) & 1, (cpt[i] >> 2) & 1); + */ + // This is where we look for any virtual addresses that map to physical address 0x03000000 and + // alter the cachable and bufferable bits... + if (((cpt[i] & 0xff000000) == 0x02000000) ) + { + //printf("SOUND c and b bits not set, overwriting\n"); + if((cpt[i] & 12)==0) { + cpt[i] |= 0xFFC; + wb++; + } + } + //if ((a>=0x31 && a<=0x36) && ((cpt[i] & 12)==0)) + if (((cpt[i] & 0xff000000) == 0x03000000) ) + { + //printf("SDL c and b bits not set, overwriting\n"); + if((cpt[i] & 12)==0) { + cpt[i] |= 0xFFC; + wb++; + } + } + break; + case 3: + //printf (" -- [%08X/%d] Unsupported --\n", cpt[i],cpt[i] & 3); + break; + default: + //printf (" -- [%08X/%d] Unknown --\n", cpt[i], cpt[i] & 3); + break; + } + } + indx += 4096; + } + //printf ("%08X %08X %08X %08X\n", cpt[0], cpt[4], cpt[8], cpt[12]); + if (wb) + { + //printf("Hacking cpt\n"); + lseek (gp2x_dev, sa, SEEK_SET); + temp = write (gp2x_dev, cpt, 256*4); + printf("%d bytes written, %s\n", temp, temp == 1024 ? "yay!" : "oh fooble :(!"); + } +} + +void dumppgtable (unsigned int ttb) +{ + unsigned int pgtable[4096]; + char *desctypes[] = {"Invalid", "Coarse", "Section", "Fine"}; + + memset (pgtable, 0, 4096*4); + lseek (gp2x_dev, ttb, SEEK_SET); + read (gp2x_dev, pgtable, 4096*4); + + int i; + for (i = 0; i < 4096; i ++) + { + int temp; + + if (pgtable[i]) + { + //printf ("Indx: %d VA: %08X Type: %d [%s] \n", i, i * 1048576, pgtable[i] & 3, desctypes[pgtable[i]&3]); + switch (pgtable[i]&3) + { + case 0: + //printf (" -- Invalid --\n"); + break; + case 1: + DecodeCoarse(i, pgtable[i]); + break; + case 2: + temp = pgtable[i] & 0xFFF00000; + //printf (" PA: %08X - %08X A: %d D: %d C: %d B: %d\n", temp, temp | 0xFFFFF, + // (pgtable[i] >> 10) & 3, (pgtable[i] >> 5) & 15, (pgtable[i] >> 3) & 1, + // (pgtable[i] >> 2) & 1); + + break; + case 3: + printf (" -- Unsupported! --\n"); + break; + } + } + } +} + +int hackpgtable (void) +{ + unsigned int oldc1, oldc2, oldc3, oldc4; + unsigned int newc1 = 0xee120f10, newc2 = 0xe12fff1e; + unsigned int ttb, ttx; + int a=0;int try=0; + // We need to execute a "MRC p15, 0, r0, c2, c0, 0", to get the pointer to the translation table base, but we can't + // do this in user mode, so we have to patch the kernel to get it to run it for us in supervisor mode. We dothis + // at the moment by overwriting the sys_newuname function and then calling it. + + lseek (gp2x_dev, 0x6ec00, SEEK_SET); // fixme: We should ask the kernel for this address rather than assuming it... + read (gp2x_dev, &oldc1, 4); + read (gp2x_dev, &oldc2, 4); + read (gp2x_dev, &oldc3, 4); + read (gp2x_dev, &oldc4, 4); + + printf ("0:%08X %08X - %08X %08X\n", oldc1, oldc2, newc1, newc2); + + + + printf ("point1 %d\n",a); + do { + lseek (gp2x_dev, 0x6ec00, SEEK_SET); + a+=write (gp2x_dev, &newc1, 4); + a+=write (gp2x_dev, &newc2, 4); + SDL_Delay(200); + try++; + ttb = myuname(name); + printf ("2:%08X try %d\n", ttb,try); + } while (ttb==0 && try<4); + + + + lseek (gp2x_dev, 0x6ec00, SEEK_SET); + a+=write (gp2x_dev, &oldc1, 4); + a+=write (gp2x_dev, &oldc2, 4); + + printf ("2:%08X %d\n", ttb,a); + if (ttb!=0) { + + + //printf ("Restored contents\n"); + + // We now have the translation table base ! Walk the table looking for our allocation and hack it :) + dumppgtable(ttb); + + // Now drain the write buffer and flush the tlb caches. Something else we can't do in user mode... + unsigned int tlbc1 = 0xe3a00000; // mov r0, #0 + unsigned int tlbc2 = 0xee070f9a; // mcr 15, 0, r0, cr7, cr10, 4 + unsigned int tlbc3 = 0xee080f17; // mcr 15, 0, r0, cr8, cr7, 0 + unsigned int tlbc4 = 0xe1a0f00e; // mov pc, lr + + lseek (gp2x_dev, 0x6ec00, SEEK_SET); + write (gp2x_dev, &tlbc1, 4); + write (gp2x_dev, &tlbc2, 4); + write (gp2x_dev, &tlbc3, 4); + write (gp2x_dev, &tlbc4, 4); + + SDL_Delay(200); + + ttx = myuname(name); + + printf ("Return from uname: %08X\n", ttx); + + lseek (gp2x_dev, 0x6ec00, SEEK_SET); + write (gp2x_dev, &oldc1, 4); + write (gp2x_dev, &oldc2, 4); + write (gp2x_dev, &oldc3, 4); + write (gp2x_dev, &oldc4, 4); + lseek (gp2x_dev, 0x0, SEEK_SET); + return 0; + } + + lseek (gp2x_dev, 0x0, SEEK_SET); + return 1; + //printf ("Restored contents\n"); + + //printf ("Pagetable after modification!\n"); + //printf ("-------------------------------\n"); + //dumppgtable(ttb); +} + +/* +****** [END] Squidge's MMU hack code ****** +*/ + +void SetClock (unsigned c) +{ + unsigned v; + unsigned mdiv,pdiv=3,scale=0; + + // Set ARM920t clock + c *= 1000000; + mdiv = (c*pdiv) / SYS_CLK_FREQ; + mdiv = ((mdiv-8)<<8) & 0xff00; + pdiv = ((pdiv-2)<<2) & 0xfc; + scale &= 3; + v = mdiv | pdiv | scale; + gp2x_memregs[0x910>>1] = v; +} + +void MMUpatch (void) +{ + volatile unsigned int *secbuf = (unsigned int *)malloc (204800); + + // Squidge's MMU hack + hackpgtable(); +} diff --git a/backends/platform/gp2x/gp2x-mem.h b/backends/platform/gp2x/gp2x-mem.h new file mode 100644 index 0000000000..a7a5490205 --- /dev/null +++ b/backends/platform/gp2x/gp2x-mem.h @@ -0,0 +1,57 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2005-2006 John Willis (Portions of the GP2X Backend) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +/* + * GP2X: Memory Stuff. + * + */ + +#ifndef GP2X_MEM_H +#define GP2X_MEM_H + +#ifdef __cplusplus +extern "C" { +#endif + + +// Use Squidge's MMU patch rather then myown (his is neater). +// The effect if not that great but cacheing the upper RAM is no bad thing (tm) ;). + +void InitRam (void); +void CloseRam (void); +// Set ARM920t clock frequency +void SetClock (unsigned c); +void MMUpatch (void); + +#define SYS_CLK_FREQ 7372800 + +char name[256]; +unsigned long gp2x_dev; +volatile unsigned short *gp2x_ram, *gp2x_memregs; + +#ifdef __cplusplus + } +#endif + +#endif //GP2X_MEM_H diff --git a/backends/platform/gp2x/gp2x.cpp b/backends/platform/gp2x/gp2x.cpp new file mode 100644 index 0000000000..7da510ad29 --- /dev/null +++ b/backends/platform/gp2x/gp2x.cpp @@ -0,0 +1,298 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2005-2006 John Willis (Portions of the GP2X Backend) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +/* + * GP2X: Main backend. + * + */ + +#include "backends/platform/gp2x/gp2x-common.h" +#include "backends/platform/gp2x/gp2x-hw.h" +#include "backends/platform/gp2x/gp2x-mem.h" +#include "common/config-manager.h" +#include "common/util.h" +#include "base/main.h" + +#if defined(HAVE_CONFIG_H) +#include "config.h" +#endif + +int main(int argc, char *argv[]) { + + // Setup GP2X upper 32MB caching + //InitRam(); + //MMUpatch(); + + extern OSystem *OSystem_GP2X_create(); + g_system = OSystem_GP2X_create(); + assert(g_system); + + // Invoke the actual ScummVM main entry point: + int res = scummvm_main(argc, argv); + g_system->quit(); + return res; +} + +OSystem *OSystem_GP2X_create() { + return new OSystem_GP2X(); +} + +void OSystem_GP2X::initBackend() { + assert(!_inited); + + ConfMan.set("joystick_num", 0); + int joystick_num = ConfMan.getInt("joystick_num"); + uint32 sdlFlags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER; + + if (ConfMan.hasKey("disable_sdl_parachute")) + sdlFlags |= SDL_INIT_NOPARACHUTE; + + if (joystick_num > -1) + sdlFlags |= SDL_INIT_JOYSTICK; + + if (SDL_Init(sdlFlags) == -1) { + error("Could not initialize SDL: %s", SDL_GetError()); + } + + // TODO: Clean way of flushing the file on every write without resorting to this or hacking the POSIX FS code. + //system("/bin/mount -t vfat -o remount,sync,iocharset=utf8 /dev/mmcsd/disc0/part1 /mnt/sd"); + + _graphicsMutex = createMutex(); + + _cksumValid = false; + _mode = GFX_NORMAL; + _scaleFactor = 0; + _scalerProc = Normal1x; + _fullscreen = true; + _adjustAspectRatio = ConfMan.getBool("aspect_ratio"); + _scalerType = 0; + _modeFlags = 0; + _adjustZoomOnMouse = false; + ConfMan.setBool("FM_low_quality", true); + + // enable joystick + if (joystick_num > -1 && SDL_NumJoysticks() > 0) { + printf("Using joystick: %s\n", SDL_JoystickName(0)); + _joystick = SDL_JoystickOpen(joystick_num); + } + + // Initialise any GP2X specific stuff we may want (Volume, Batt Status etc.) + GP2X_device_init(); + + // Set Default hardware mixer volume to a plesent level. + // This is done to 'reset' volume level if set by other apps. + GP2X_mixer_set_volume(70, 70); + + SDL_ShowCursor(SDL_DISABLE); + + _inited = true; +} + +OSystem_GP2X::OSystem_GP2X() + : + _osdSurface(0), _osdAlpha(SDL_ALPHA_TRANSPARENT), _osdFadeStartTime(0), + _hwscreen(0), _screen(0), _screenWidth(0), _screenHeight(0), + _tmpscreen(0), _overlayWidth(0), _overlayHeight(0), + _overlayVisible(false), + _overlayscreen(0), _tmpscreen2(0), + _samplesPerSec(0), + _cdrom(0), _scalerProc(0), _modeChanged(false), _screenChangeCount(0), _dirtyChecksums(0), + _mouseVisible(false), _mouseDrawn(false), _mouseData(0), _mouseSurface(0), + _mouseOrigSurface(0), _cursorTargetScale(1), _cursorPaletteDisabled(true), + _joystick(0), + _currentShakePos(0), _newShakePos(0), + _paletteDirtyStart(0), _paletteDirtyEnd(0), + _graphicsMutex(0), _transactionMode(kTransactionNone) { + + // allocate palette storage + _currentPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256); + _cursorPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256); + + _mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0; + + // reset mouse state + memset(&_km, 0, sizeof(_km)); + memset(&_mouseCurState, 0, sizeof(_mouseCurState)); + + _inited = false; +} + +OSystem_GP2X::~OSystem_GP2X() { + free(_dirtyChecksums); + free(_currentPalette); + free(_cursorPalette); + free(_mouseData); +} + +uint32 OSystem_GP2X::getMillis() { + return SDL_GetTicks(); +} + +void OSystem_GP2X::delayMillis(uint msecs) { + SDL_Delay(msecs); +} + +void OSystem_GP2X::setTimerCallback(TimerProc callback, int timer) { + SDL_SetTimer(timer, (SDL_TimerCallback) callback); +} + +bool OSystem_GP2X::hasFeature(Feature f) { + return + (f == kFeatureFullscreenMode) || + (f == kFeatureAspectRatioCorrection) || + (f == kFeatureAutoComputeDirtyRects) || + (f == kFeatureCursorHasPalette); +} + +void OSystem_GP2X::setFeatureState(Feature f, bool enable) { + switch (f) { + case kFeatureFullscreenMode: + return; + case kFeatureAspectRatioCorrection: + setAspectRatioCorrection(enable); + break; + case kFeatureAutoComputeDirtyRects: + if (enable) + _modeFlags |= DF_WANT_RECT_OPTIM; + else + _modeFlags &= ~DF_WANT_RECT_OPTIM; + break; + default: + break; + } +} + +bool OSystem_GP2X::getFeatureState(Feature f) { + assert (_transactionMode == kTransactionNone); + + switch (f) { + case kFeatureFullscreenMode: + return false; + //case kFeatureFullscreenMode: + // return _fullscreen; + case kFeatureAspectRatioCorrection: + return _adjustAspectRatio; + case kFeatureAutoComputeDirtyRects: + return _modeFlags & DF_WANT_RECT_OPTIM; + default: + return false; + } +} + +void OSystem_GP2X::quit() { + unloadGFXMode(); + deleteMutex(_graphicsMutex); + + if (_joystick) + SDL_JoystickClose(_joystick); + //CloseRam(); + GP2X_device_deinit(); + SDL_Quit(); + chdir("/usr/gp2x"); + execl("/usr/gp2x/gp2xmenu", "/usr/gp2x/gp2xmenu", NULL); +} + +OSystem::MutexRef OSystem_GP2X::createMutex(void) { + return (MutexRef) SDL_CreateMutex(); +} + +void OSystem_GP2X::lockMutex(MutexRef mutex) { + SDL_mutexP((SDL_mutex *) mutex); +} + +void OSystem_GP2X::unlockMutex(MutexRef mutex) { + SDL_mutexV((SDL_mutex *) mutex); +} + +void OSystem_GP2X::deleteMutex(MutexRef mutex) { + SDL_DestroyMutex((SDL_mutex *) mutex); +} + +#pragma mark - +#pragma mark --- Audio --- +#pragma mark - + +bool OSystem_GP2X::setSoundCallback(SoundProc proc, void *param) { + SDL_AudioSpec desired; + SDL_AudioSpec obtained; + + memset(&desired, 0, sizeof(desired)); + + _samplesPerSec = 0; + + if (ConfMan.hasKey("output_rate")) + _samplesPerSec = ConfMan.getInt("output_rate"); + + if (_samplesPerSec <= 0) + _samplesPerSec = SAMPLES_PER_SEC; + + //Quick EVIL Hack - DJWillis + _samplesPerSec = 11025; + + desired.freq = _samplesPerSec; + desired.format = AUDIO_S16SYS; + desired.channels = 2; + //desired.samples = (uint16)samples; + desired.samples = 128; // Samples hack + desired.callback = proc; + desired.userdata = param; + if (SDL_OpenAudio(&desired, &obtained) != 0) { + warning("Could not open audio device: %s", SDL_GetError()); + return false; + } + _samplesPerSec = obtained.freq; + SDL_PauseAudio(0); + return true; +} + +void OSystem_GP2X::clearSoundCallback() { + SDL_CloseAudio(); +} + +int OSystem_GP2X::getOutputSampleRate() const { + return _samplesPerSec; +} + +#pragma mark - +#pragma mark --- CD Audio --- +#pragma mark - + +bool OSystem_GP2X::openCD(int drive) { + return (_cdrom = NULL); +} + +void OSystem_GP2X::stopCD() { +} + +void OSystem_GP2X::playCD(int track, int num_loops, int start_frame, int duration) { + return; +} + +bool OSystem_GP2X::pollCD() { + return false; +} + +void OSystem_GP2X::updateCD() { + return; +} diff --git a/backends/platform/gp2x/graphics.cpp b/backends/platform/gp2x/graphics.cpp new file mode 100644 index 0000000000..64f31f10e4 --- /dev/null +++ b/backends/platform/gp2x/graphics.cpp @@ -0,0 +1,1722 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2005-2006 John Willis (Portions of the GP2X Backend) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +/* + * GP2X: Graphics handling. + * + */ + +#include "backends/platform/gp2x/gp2x-common.h" +#include "graphics/scaler.h" +#include "common/util.h" +#include "graphics/font.h" +#include "graphics/fontman.h" +#include "graphics/surface.h" + +static const OSystem::GraphicsMode s_supportedGraphicsModes[] = { + {"GP2X Graphics Mode", "1x", GFX_NORMAL}, + {0, 0, 0} +}; + +// Table of relative scalers magnitudes +// [definedScale - 1][_scaleFactor - 1] +static ScalerProc *scalersMagn[3][3] = { + { Normal1x, Normal1x, Normal1x }, + { Normal1x, Normal1x, Normal1x }, + { Normal1x, Normal1x, Normal1x } +}; + +static const int s_gfxModeSwitchTable[][4] = { + { GFX_NORMAL, GFX_DOUBLESIZE, GFX_TRIPLESIZE, -1 }, + { GFX_NORMAL, GFX_ADVMAME2X, GFX_ADVMAME3X, -1 }, + { GFX_NORMAL, GFX_HQ2X, GFX_HQ3X, -1 }, + { GFX_NORMAL, GFX_2XSAI, -1, -1 }, + { GFX_NORMAL, GFX_SUPER2XSAI, -1, -1 }, + { GFX_NORMAL, GFX_SUPEREAGLE, -1, -1 }, + { GFX_NORMAL, GFX_TV2X, -1, -1 }, + { GFX_NORMAL, GFX_DOTMATRIX, -1, -1 } + }; + +static int cursorStretch200To240(uint8 *buf, uint32 pitch, int width, int height, int srcX, int srcY, int origSrcY); + +const OSystem::GraphicsMode *OSystem_GP2X::getSupportedGraphicsModes() const { + return s_supportedGraphicsModes; +} + +int OSystem_GP2X::getDefaultGraphicsMode() const { + return GFX_NORMAL; +} + +void OSystem_GP2X::beginGFXTransaction(void) { + assert (_transactionMode == kTransactionNone); + + _transactionMode = kTransactionActive; + + _transactionDetails.modeChanged = false; + _transactionDetails.sizeChanged = false; + _transactionDetails.arChanged = false; + _transactionDetails.fsChanged = false; + + _transactionDetails.needHotswap = false; + _transactionDetails.needUpdatescreen = false; + _transactionDetails.needUnload = false; + + _transactionDetails.normal1xScaler = false; +} + +void OSystem_GP2X::endGFXTransaction(void) { + // for each engine we run initCommonGFX() as first thing in the transaction + // and initSize() is called later. If user runs launcher at 320x200 with + // 2x overlay, setting to Nomral1x sclaler in that case will be suppressed + // and backend is forced to 2x + // + // This leads to bad results such as 1280x960 window for 640x480 engines. + // To prevent that we rerun setGraphicsMode() if there was 1x scaler request + if (_transactionDetails.normal1xScaler) + setGraphicsMode(GFX_NORMAL); + + assert (_transactionMode == kTransactionActive); + + _transactionMode = kTransactionCommit; + if (_transactionDetails.modeChanged) + setGraphicsMode(_transactionDetails.mode); + + if (_transactionDetails.sizeChanged) + initSize(_transactionDetails.w, _transactionDetails.h); + + if (_transactionDetails.arChanged) + setAspectRatioCorrection(_transactionDetails.ar); + + if (_transactionDetails.needUnload) { + unloadGFXMode(); + loadGFXMode(); + clearOverlay(); + } else { + if (!_transactionDetails.fsChanged) { + if (_transactionDetails.needHotswap) + hotswapGFXMode(); + else if (_transactionDetails.needUpdatescreen) + internUpdateScreen(); + } + } + + if (_transactionDetails.fsChanged) + setFullscreenMode(_transactionDetails.fs); + + _transactionMode = kTransactionNone; +} + +bool OSystem_GP2X::setGraphicsMode(int mode) { + Common::StackLock lock(_graphicsMutex); + + int newScaleFactor = 1; + ScalerProc *newScalerProc; + + mode = GFX_NORMAL; + newScaleFactor = 1; + newScalerProc = Normal1x; + + _transactionDetails.normal1xScaler = (mode == GFX_NORMAL); + + _mode = mode; + _scalerProc = newScalerProc; + + if (_transactionMode == kTransactionActive) { + _transactionDetails.mode = mode; + _transactionDetails.modeChanged = true; + + if (newScaleFactor != _scaleFactor) { + _transactionDetails.needHotswap = true; + _scaleFactor = newScaleFactor; + } + + _transactionDetails.needUpdatescreen = true; + + return true; + } + + // NOTE: This should not be executed at transaction commit + // Otherwise there is some unsolicited setGraphicsMode() call + // which should be properly removed + if (newScaleFactor != _scaleFactor) { + assert(_transactionMode != kTransactionCommit); + + _scaleFactor = newScaleFactor; + hotswapGFXMode(); + } + + // Determine the "scaler type", i.e. essentially an index into the + // s_gfxModeSwitchTable array defined in events.cpp. + if (_mode != GFX_NORMAL) { + for (int i = 0; i < ARRAYSIZE(s_gfxModeSwitchTable); i++) { + if (s_gfxModeSwitchTable[i][1] == _mode || s_gfxModeSwitchTable[i][2] == _mode) { + _scalerType = i; + break; + } + } + } + + if (!_screen) + return true; + + // Blit everything to the screen + _forceFull = true; + + // Even if the old and new scale factors are the same, we may have a + // different scaler for the cursor now. + blitCursor(); + + if (_transactionMode != kTransactionCommit) + internUpdateScreen(); + + // Make sure that an EVENT_SCREEN_CHANGED gets sent later + _modeChanged = true; + + return true; +} + +int OSystem_GP2X::getGraphicsMode() const { + assert (_transactionMode == kTransactionNone); + return _mode; +} + +void OSystem_GP2X::initSize(uint w, uint h){ + // Avoid redundant res changes + if ((int)w == _screenWidth && (int)h == _screenHeight && + _transactionMode != kTransactionCommit) + return; + + _screenWidth = w; + _screenHeight = h; + + _cksumNum = (_screenWidth * _screenHeight / (8 * 8)); + + if (_transactionMode == kTransactionActive) { + _transactionDetails.w = w; + _transactionDetails.h = h; + _transactionDetails.sizeChanged = true; + + _transactionDetails.needUnload = true; + + return; + } + + free(_dirtyChecksums); + _dirtyChecksums = (uint32 *)calloc(_cksumNum * 2, sizeof(uint32)); + + if (_transactionMode != kTransactionCommit) { + unloadGFXMode(); + loadGFXMode(); + + // if initSize() gets called in the middle, overlay is not transparent + clearOverlay(); + } +} + +void OSystem_GP2X::loadGFXMode() { + + //enable 320x240 image to fit the 320x240 display area (aka, disable scaling) + //gp2x_video_RGB_setscaling(320,240); + + assert(_inited); + _forceFull = true; + _modeFlags |= DF_UPDATE_EXPAND_1_PIXEL; + + int hwW, hwH; + +#ifndef __MAEMO__ + _overlayWidth = _screenWidth * _scaleFactor; + _overlayHeight = _screenHeight * _scaleFactor; + + if (_screenHeight != 200) + _adjustAspectRatio = false; + + if (_adjustAspectRatio) + _overlayHeight = real2Aspect(_overlayHeight); + + hwW = _screenWidth * _scaleFactor; + hwH = effectiveScreenHeight(); +#else + hwW = _overlayWidth; + hwH = _overlayHeight; +#endif + + // + // Create the surface that contains the 8 bit game data + // + _screen = SDL_CreateRGBSurface(SDL_SWSURFACE, _screenWidth, _screenHeight, 8, 0, 0, 0, 0); + if (_screen == NULL) + error("allocating _screen failed"); + + // + // Create the surface that contains the graphics in 16 bit mode + // + + // FIXME: Hack for GP2X SDL querks. + if (_screenWidth <= 320) { + _hwscreen = SDL_SetVideoMode(320, 240, 16, SDL_FULLSCREEN|SDL_SWSURFACE); + } else { + _hwscreen = SDL_SetVideoMode(_screenWidth, _screenHeight, 16, SDL_FULLSCREEN|SDL_SWSURFACE); + } + + if (_hwscreen == NULL) { + warning("SDL_SetVideoMode says we can't switch to that mode"); + quit(); + } + + // GP2X Specific, must be called after any SDL_SetVideoMode to ensure the hardware cursor is off. + // Note: On the GP2X SDL_SetVideoMode recalls SDL_Init(). + SDL_ShowCursor(SDL_DISABLE); + + + // + // Create the surface used for the graphics in 16 bit before scaling, and also the overlay + // + + // Distinguish 555 and 565 mode + if (_hwscreen->format->Rmask == 0x7C00) + InitScalers(555); + else + InitScalers(565); + + // Need some extra bytes around when using 2xSaI + _tmpscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _screenWidth + 3, _screenHeight + 3, + 16, + _hwscreen->format->Rmask, + _hwscreen->format->Gmask, + _hwscreen->format->Bmask, + _hwscreen->format->Amask); + + if (_tmpscreen == NULL) + error("allocating _tmpscreen failed"); + + _overlayscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _overlayWidth, _overlayHeight, + 16, + _hwscreen->format->Rmask, + _hwscreen->format->Gmask, + _hwscreen->format->Bmask, + _hwscreen->format->Amask); + + if (_overlayscreen == NULL) + error("allocating _overlayscreen failed"); + + _tmpscreen2 = SDL_CreateRGBSurface(SDL_SWSURFACE, _overlayWidth + 3, _overlayHeight + 3, + 16, + _hwscreen->format->Rmask, + _hwscreen->format->Gmask, + _hwscreen->format->Bmask, + _hwscreen->format->Amask); + + if (_tmpscreen2 == NULL) + error("allocating _tmpscreen2 failed"); + + _osdSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, + _hwscreen->w, + _hwscreen->h, + 16, + _hwscreen->format->Rmask, + _hwscreen->format->Gmask, + _hwscreen->format->Bmask, + _hwscreen->format->Amask); + if (_osdSurface == NULL) + error("allocating _osdSurface failed"); + SDL_SetColorKey(_osdSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kOSDColorKey); + + // keyboard cursor control, some other better place for it? + _km.x_max = _screenWidth * _scaleFactor - 1; + _km.y_max = effectiveScreenHeight() - 1; + _km.delay_time = 25; + _km.last_time = 0; + +} + +void OSystem_GP2X::unloadGFXMode() { + if (_screen) { + SDL_FreeSurface(_screen); + _screen = NULL; + } + + if (_hwscreen) { + SDL_FreeSurface(_hwscreen); + _hwscreen = NULL; + } + + if (_tmpscreen) { + SDL_FreeSurface(_tmpscreen); + _tmpscreen = NULL; + } + + if (_tmpscreen2) { + SDL_FreeSurface(_tmpscreen2); + _tmpscreen2 = NULL; + } + + if (_overlayscreen) { + SDL_FreeSurface(_overlayscreen); + _overlayscreen = NULL; + } + + if (_osdSurface) { + SDL_FreeSurface(_osdSurface); + _osdSurface = NULL; + } +} + +void OSystem_GP2X::hotswapGFXMode() { + if (!_screen) + return; + + // Keep around the old _screen & _overlayscreen so we can restore the screen data + // after the mode switch. + SDL_Surface *old_screen = _screen; + SDL_Surface *old_overlayscreen = _overlayscreen; + + // Release the HW screen surface + SDL_FreeSurface(_hwscreen); + + SDL_FreeSurface(_tmpscreen); + SDL_FreeSurface(_tmpscreen2); + + // Release the OSD surface + SDL_FreeSurface(_osdSurface); + + // Setup the new GFX mode + loadGFXMode(); + + // reset palette + SDL_SetColors(_screen, _currentPalette, 0, 256); + + // Restore old screen content + SDL_BlitSurface(old_screen, NULL, _screen, NULL); + SDL_BlitSurface(old_overlayscreen, NULL, _overlayscreen, NULL); + + // Free the old surfaces + SDL_FreeSurface(old_screen); + SDL_FreeSurface(old_overlayscreen); + + // Update cursor to new scale + blitCursor(); + + // Blit everything to the screen + internUpdateScreen(); + + // Make sure that an EVENT_SCREEN_CHANGED gets sent later + _modeChanged = true; +} + +void OSystem_GP2X::updateScreen() { + assert (_transactionMode == kTransactionNone); + + Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends + + internUpdateScreen(); +} + +void OSystem_GP2X::internUpdateScreen() { + SDL_Surface *srcSurf, *origSurf; + int height, width; + ScalerProc *scalerProc; + int scale1; + +#if defined (DEBUG) && ! defined(_WIN32_WCE) // definitions not available for non-DEBUG here. (needed this to compile in SYMBIAN32 & linux?) + assert(_hwscreen != NULL); + assert(_hwscreen->map->sw_data != NULL); +#endif + + // If the shake position changed, fill the dirty area with blackness + if (_currentShakePos != _newShakePos) { + SDL_Rect blackrect = {0, 0, _screenWidth * _scaleFactor, _newShakePos * _scaleFactor}; + + if (_adjustAspectRatio && !_overlayVisible) + blackrect.h = real2Aspect(blackrect.h - 1) + 1; + + SDL_FillRect(_hwscreen, &blackrect, 0); + + _currentShakePos = _newShakePos; + + _forceFull = true; + } + + // Check whether the palette was changed in the meantime and update the + // screen surface accordingly. + if (_screen && _paletteDirtyEnd != 0) { + SDL_SetColors(_screen, _currentPalette + _paletteDirtyStart, + _paletteDirtyStart, + _paletteDirtyEnd - _paletteDirtyStart); + + _paletteDirtyEnd = 0; + + _forceFull = true; + } + // OSD visible (i.e. non-transparent)? + if (_osdAlpha != SDL_ALPHA_TRANSPARENT) { + // Updated alpha value + const int diff = SDL_GetTicks() - _osdFadeStartTime; + if (diff > 0) { + if (diff >= kOSDFadeOutDuration) { + // Back to full transparency + _osdAlpha = SDL_ALPHA_TRANSPARENT; + } else { + // Do a linear fade out... + const int startAlpha = SDL_ALPHA_TRANSPARENT + kOSDInitialAlpha * (SDL_ALPHA_OPAQUE - SDL_ALPHA_TRANSPARENT) / 100; + _osdAlpha = startAlpha + diff * (SDL_ALPHA_TRANSPARENT - startAlpha) / kOSDFadeOutDuration; + } + SDL_SetAlpha(_osdSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, _osdAlpha); + _forceFull = true; + } + } + + if (!_overlayVisible) { + origSurf = _screen; + srcSurf = _tmpscreen; + width = _screenWidth; + height = _screenHeight; + scalerProc = _scalerProc; + scale1 = _scaleFactor; + } else { + origSurf = _overlayscreen; + srcSurf = _tmpscreen2; + width = _overlayWidth; + height = _overlayHeight; + scalerProc = Normal1x; + + scale1 = 1; + } + + // Force a full redraw if requested + if (_forceFull) { + _numDirtyRects = 1; + _dirtyRectList[0].x = 0; + _dirtyRectList[0].y = 0; + _dirtyRectList[0].w = width; + _dirtyRectList[0].h = height; + } else + undrawMouse(); + + // Only draw anything if necessary + if (_numDirtyRects > 0) { + + SDL_Rect *r; + SDL_Rect dst; + uint32 srcPitch, dstPitch; + SDL_Rect *lastRect = _dirtyRectList + _numDirtyRects; + + if (scalerProc == Normal1x && !_adjustAspectRatio && 0) { + for (r = _dirtyRectList; r != lastRect; ++r) { + dst = *r; + + dst.y += _currentShakePos; + if (SDL_BlitSurface(origSurf, r, _hwscreen, &dst) != 0) + error("SDL_BlitSurface failed: %s", SDL_GetError()); + } + } else { + for (r = _dirtyRectList; r != lastRect; ++r) { + dst = *r; + dst.x++; // Shift rect by one since 2xSai needs to acces the data around + dst.y++; // any pixel to scale it, and we want to avoid mem access crashes. + + if (SDL_BlitSurface(origSurf, r, srcSurf, &dst) != 0) + error("SDL_BlitSurface failed: %s", SDL_GetError()); + } + + SDL_LockSurface(srcSurf); + SDL_LockSurface(_hwscreen); + + srcPitch = srcSurf->pitch; + dstPitch = _hwscreen->pitch; + + for (r = _dirtyRectList; r != lastRect; ++r) { + register int dst_y = r->y + _currentShakePos; + register int dst_h = 0; + register int orig_dst_y = 0; + register int rx1 = r->x * scale1; + + if (dst_y < height) { + dst_h = r->h; + if (dst_h > height - dst_y) + dst_h = height - dst_y; + + orig_dst_y = dst_y; + dst_y = dst_y * scale1; + + if (_adjustAspectRatio && !_overlayVisible) + dst_y = real2Aspect(dst_y); + + assert(scalerProc != NULL); + scalerProc((byte *)srcSurf->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch, + (byte *)_hwscreen->pixels + rx1 * 2 + dst_y * dstPitch, dstPitch, r->w, dst_h); + } + + r->x = rx1; + r->y = dst_y; + r->w = r->w * scale1; + r->h = dst_h * scale1; + +#ifndef DISABLE_SCALERS + if (_adjustAspectRatio && orig_dst_y < height && !_overlayVisible) + r->h = stretch200To240((uint8 *) _hwscreen->pixels, dstPitch, r->w, r->h, r->x, r->y, orig_dst_y * scale1); +#endif + } + SDL_UnlockSurface(srcSurf); + SDL_UnlockSurface(_hwscreen); + } + + // Readjust the dirty rect list in case we are doing a full update. + // This is necessary if shaking is active. + if (_forceFull) { + _dirtyRectList[0].y = 0; + _dirtyRectList[0].h = effectiveScreenHeight(); + } + + drawMouse(); + + if (_osdAlpha != SDL_ALPHA_TRANSPARENT) { + SDL_BlitSurface(_osdSurface, 0, _hwscreen, 0); + } + + // Finally, blit all our changes to the screen + SDL_UpdateRects(_hwscreen, _numDirtyRects, _dirtyRectList); + } else { + drawMouse(); + if (_numDirtyRects) + SDL_UpdateRects(_hwscreen, _numDirtyRects, _dirtyRectList); + } + + _numDirtyRects = 0; + _forceFull = false; +} + +bool OSystem_GP2X::saveScreenshot(const char *filename) { + assert(_hwscreen != NULL); + + Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends + return SDL_SaveBMP(_hwscreen, filename) == 0; +} + +void OSystem_GP2X::setFullscreenMode(bool enable) { + Common::StackLock lock(_graphicsMutex); + + if (_fullscreen != enable || _transactionMode == kTransactionCommit) { + assert(_hwscreen != 0); + _fullscreen = enable; + + if (_transactionMode == kTransactionActive) { + _transactionDetails.fs = enable; + _transactionDetails.fsChanged = true; + + _transactionDetails.needHotswap = true; + + return; + } + +#if (defined(MACOSX) && !SDL_VERSION_ATLEAST(1, 2, 6)) || defined(__MAEMO__) + // On OS X, SDL_WM_ToggleFullScreen is currently not implemented. Worse, + // before SDL 1.2.6 it always returned -1 (which would indicate a + // successful switch). So we simply don't call it at all and use + // hotswapGFXMode() directly to switch to fullscreen mode. + hotswapGFXMode(); +#else + if (!SDL_WM_ToggleFullScreen(_hwscreen)) { + // if ToggleFullScreen fails, achieve the same effect with hotswap gfx mode + hotswapGFXMode(); + } else { + // Blit everything to the screen + internUpdateScreen(); + + // Make sure that an EVENT_SCREEN_CHANGED gets sent later + _modeChanged = true; + } +#endif + } +} + +void OSystem_GP2X::setAspectRatioCorrection(bool enable) { + if ((_screenHeight == 200 && _adjustAspectRatio != enable) || + _transactionMode == kTransactionCommit) { + Common::StackLock lock(_graphicsMutex); + + //assert(_hwscreen != 0); + _adjustAspectRatio = enable; + + if (_transactionMode == kTransactionActive) { + _transactionDetails.ar = enable; + _transactionDetails.arChanged = true; + + _transactionDetails.needHotswap = true; + + return; + } else { + if (_transactionMode != kTransactionCommit) + hotswapGFXMode(); + } + + // Make sure that an EVENT_SCREEN_CHANGED gets sent later + _modeChanged = true; + } +} + +void OSystem_GP2X::setZoomOnMouse() { + if (_adjustZoomOnMouse == true) { + _adjustZoomOnMouse = false; + return; + } else { + _adjustZoomOnMouse = true; + return; + } +} + +void OSystem_GP2X::clearScreen() { + assert (_transactionMode == kTransactionNone); + + // Try to lock the screen surface + if (SDL_LockSurface(_screen) == -1) + error("SDL_LockSurface failed: %s", SDL_GetError()); + + byte *dst = (byte *)_screen->pixels; + + // Clear the screen + memset(dst, 0, _screenWidth * _screenHeight); + + // Unlock the screen surface + SDL_UnlockSurface(_screen); +} + +void OSystem_GP2X::copyRectToScreen(const byte *src, int pitch, int x, int y, int w, int h) { + assert (_transactionMode == kTransactionNone); + assert(src); + + if (_screen == NULL) + return; + + Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends + +// assert(x >= 0 && x < _screenWidth); +// assert(y >= 0 && y < _screenHeight); +// assert(h > 0 && y + h <= _screenHeight); +// assert(w > 0 && x + w <= _screenWidth); + + if (((long)src & 3) == 0 && pitch == _screenWidth && x == 0 && y == 0 && + w == _screenWidth && h == _screenHeight && _modeFlags & DF_WANT_RECT_OPTIM) { + /* Special, optimized case for full screen updates. + * It tries to determine what areas were actually changed, + * and just updates those, on the actual display. */ + addDirtyRgnAuto(src); + } else { + /* Clip the coordinates */ + if (x < 0) { + w += x; + src -= x; + x = 0; + } + + if (y < 0) { + h += y; + src -= y * pitch; + y = 0; + } + + if (w > _screenWidth - x) { + w = _screenWidth - x; + } + + if (h > _screenHeight - y) { + h = _screenHeight - y; + } + + if (w <= 0 || h <= 0) + return; + + _cksumValid = false; + addDirtyRect(x, y, w, h); + } + + // Try to lock the screen surface + if (SDL_LockSurface(_screen) == -1) + error("SDL_LockSurface failed: %s", SDL_GetError()); + + byte *dst = (byte *)_screen->pixels + y * _screenWidth + x; + + if (_screenWidth == pitch && pitch == w) { + memcpy(dst, src, h*w); + } else { + do { + memcpy(dst, src, w); + src += pitch; + dst += _screenWidth; + } while (--h); + } + + // Unlock the screen surface + SDL_UnlockSurface(_screen); +} + +bool OSystem_GP2X::grabRawScreen(Graphics::Surface *surf) { + assert(_screen); + assert(surf); + + Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends + + surf->create(_screenWidth, _screenHeight, _screen->format->BytesPerPixel); + + // Try to lock the screen surface + if (SDL_LockSurface(_screen) == -1) + error("SDL_LockSurface failed: %s", SDL_GetError()); + + memcpy(surf->pixels, _screen->pixels, _screenWidth * _screenHeight * _screen->format->BytesPerPixel); + + // Unlock the screen surface + SDL_UnlockSurface(_screen); + + return true; +} + +void OSystem_GP2X::addDirtyRect(int x, int y, int w, int h, bool realCoordinates) { + if (_forceFull) + return; + + if (_numDirtyRects == NUM_DIRTY_RECT) { + _forceFull = true; + return; + } + + int height, width; + + if (!_overlayVisible && !realCoordinates) { + width = _screenWidth; + height = _screenHeight; + } else { + width = _overlayWidth; + height = _overlayHeight; + } + + // Extend the dirty region by 1 pixel for scalers + // that "smear" the screen, e.g. 2xSAI + if ((_modeFlags & DF_UPDATE_EXPAND_1_PIXEL) && !realCoordinates) { + x--; + y--; + w+=2; + h+=2; + } + + // clip + if (x < 0) { + w += x; + x = 0; + } + + if (y < 0) { + h += y; + y=0; + } + + if (w > width - x) { + w = width - x; + } + + if (h > height - y) { + h = height - y; + } + +#ifndef DISABLE_SCALERS + if (_adjustAspectRatio && !_overlayVisible && !realCoordinates) { + makeRectStretchable(x, y, w, h); + } +#endif + + if (w == width && h == height) { + _forceFull = true; + return; + } + + if (w > 0 && h > 0) { + SDL_Rect *r = &_dirtyRectList[_numDirtyRects++]; + + r->x = x; + r->y = y; + r->w = w; + r->h = h; + } +} + +void OSystem_GP2X::makeChecksums(const byte *buf) { + assert(buf); + uint32 *sums = _dirtyChecksums; + uint x,y; + const uint last_x = (uint)_screenWidth / 8; + const uint last_y = (uint)_screenHeight / 8; + + const uint BASE = 65521; /* largest prime smaller than 65536 */ + + /* the 8x8 blocks in buf are enumerated starting in the top left corner and + * reading each line at a time from left to right */ + for (y = 0; y != last_y; y++, buf += _screenWidth * (8 - 1)) + for (x = 0; x != last_x; x++, buf += 8) { // Adler32 checksum algorithm (from RFC1950, used by gzip and zlib). + // Adler32 checksum algorithm (from RFC1950, used by gzip and zlib). + // This computes the Adler32 checksum of a 8x8 pixel block. Note + // that we can do the modulo operation (which is the slowest part) + // of the algorithm) at the end, instead of doing each iteration, + // since we only have 64 iterations in total - and thus s1 and + // s2 can't overflow anyway. + uint32 s1 = 1; + uint32 s2 = 0; + const byte *ptr = buf; + for (int subY = 0; subY < 8; subY++) { + for (int subX = 0; subX < 8; subX++) { + s1 += ptr[subX]; + s2 += s1; + } + ptr += _screenWidth; + } + + s1 %= BASE; + s2 %= BASE; + + /* output the checksum for this block */ + *sums++ = (s2 << 16) + s1; + } +} + +void OSystem_GP2X::addDirtyRgnAuto(const byte *buf) { + assert(buf); + assert(((long)buf & 3) == 0); + + /* generate a table of the checksums */ + makeChecksums(buf); + + if (!_cksumValid) { + _forceFull = true; + _cksumValid = true; + } + + /* go through the checksum list, compare it with the previous checksums, + and add all dirty rectangles to a list. try to combine small rectangles + into bigger ones in a simple way */ + if (!_forceFull) { + int x, y, w; + uint32 *ck = _dirtyChecksums; + + for (y = 0; y != _screenHeight / 8; y++) { + for (x = 0; x != _screenWidth / 8; x++, ck++) { + if (ck[0] != ck[_cksumNum]) { + /* found a dirty 8x8 block, now go as far to the right as possible, + and at the same time, unmark the dirty status by setting old to new. */ + w=0; + do { + ck[w + _cksumNum] = ck[w]; + w++; + } while (x + w != _screenWidth / 8 && ck[w] != ck[w + _cksumNum]); + + addDirtyRect(x * 8, y * 8, w * 8, 8); + + if (_forceFull) + goto get_out; + } + } + } + } else { + get_out:; + /* Copy old checksums to new */ + memcpy(_dirtyChecksums + _cksumNum, _dirtyChecksums, _cksumNum * sizeof(uint32)); + } +} + +int16 OSystem_GP2X::getHeight() { + return _screenHeight; +} + +int16 OSystem_GP2X::getWidth() { + return _screenWidth; +} + +void OSystem_GP2X::setPalette(const byte *colors, uint start, uint num) { + assert(colors); + + // Setting the palette before _screen is created is allowed - for now - + // since we don't actually set the palette until the screen is updated. + // But it could indicate a programming error, so let's warn about it. + + if (!_screen) + warning("OSystem_SDL::setPalette: _screen == NULL"); + + const byte *b = colors; + uint i; + SDL_Color *base = _currentPalette + start; + for (i = 0; i < num; i++) { + base[i].r = b[0]; + base[i].g = b[1]; + base[i].b = b[2]; + b += 4; + } + + if (start < _paletteDirtyStart) + _paletteDirtyStart = start; + + if (start + num > _paletteDirtyEnd) + _paletteDirtyEnd = start + num; + + // Some games blink cursors with palette + if (_cursorPaletteDisabled) + blitCursor(); +} + +void OSystem_GP2X::grabPalette(byte *colors, uint start, uint num) { + assert(colors); + const SDL_Color *base = _currentPalette + start; + + for (uint i = 0; i < num; ++i) { + colors[i * 4] = base[i].r; + colors[i * 4 + 1] = base[i].g; + colors[i * 4 + 2] = base[i].b; + colors[i * 4 + 3] = 0xFF; + } +} + +void OSystem_GP2X::setCursorPalette(const byte *colors, uint start, uint num) { + assert(colors); + const byte *b = colors; + uint i; + SDL_Color *base = _cursorPalette + start; + for (i = 0; i < num; i++) { + base[i].r = b[0]; + base[i].g = b[1]; + base[i].b = b[2]; + b += 4; + } + + _cursorPaletteDisabled = false; + + blitCursor(); +} + +void OSystem_GP2X::setShakePos(int shake_pos) { + assert (_transactionMode == kTransactionNone); + + _newShakePos = shake_pos; +} + +#pragma mark - +#pragma mark --- Overlays --- +#pragma mark - + +void OSystem_GP2X::showOverlay() { + assert (_transactionMode == kTransactionNone); + + int x, y; + + if (_overlayVisible) + return; + + _overlayVisible = true; + + // Since resolution could change, put mouse to adjusted position + // Fixes bug #1349059 + x = _mouseCurState.x * _scaleFactor; + if (_adjustAspectRatio) + y = real2Aspect(_mouseCurState.y) * _scaleFactor; + else + y = _mouseCurState.y * _scaleFactor; + + warpMouse(x, y); + + clearOverlay(); +} + +void OSystem_GP2X::hideOverlay() { + assert (_transactionMode == kTransactionNone); + + if (!_overlayVisible) + return; + + int x, y; + + _overlayVisible = false; + + // Since resolution could change, put mouse to adjusted position + // Fixes bug #1349059 + x = _mouseCurState.x / _scaleFactor; + y = _mouseCurState.y / _scaleFactor; + if (_adjustAspectRatio) + y = aspect2Real(y); + + warpMouse(x, y); + + clearOverlay(); + + _forceFull = true; +} + +void OSystem_GP2X::clearOverlay() { + //assert (_transactionMode == kTransactionNone); + + Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends + + if (!_overlayVisible) + return; + + // Clear the overlay by making the game screen "look through" everywhere. + SDL_Rect src, dst; + src.x = src.y = 0; + dst.x = dst.y = 1; + src.w = dst.w = _screenWidth; + src.h = dst.h = _screenHeight; + if (SDL_BlitSurface(_screen, &src, _tmpscreen, &dst) != 0) + error("SDL_BlitSurface failed: %s", SDL_GetError()); + + SDL_LockSurface(_tmpscreen); + SDL_LockSurface(_overlayscreen); + _scalerProc((byte *)(_tmpscreen->pixels) + _tmpscreen->pitch + 2, _tmpscreen->pitch, + (byte *)_overlayscreen->pixels, _overlayscreen->pitch, _screenWidth, _screenHeight); + +#ifndef DISABLE_SCALERS + if (_adjustAspectRatio) + stretch200To240((uint8 *)_overlayscreen->pixels, _overlayscreen->pitch, + _overlayWidth, _screenHeight * _scaleFactor, 0, 0, 0); +#endif + SDL_UnlockSurface(_tmpscreen); + SDL_UnlockSurface(_overlayscreen); + + _forceFull = true; +} + +void OSystem_GP2X::grabOverlay(OverlayColor *buf, int pitch) { + assert (_transactionMode == kTransactionNone); + + if (_overlayscreen == NULL) + return; + + if (SDL_LockSurface(_overlayscreen) == -1) + error("SDL_LockSurface failed: %s", SDL_GetError()); + + byte *src = (byte *)_overlayscreen->pixels; + int h = _overlayHeight; + do { + memcpy(buf, src, _overlayWidth * 2); + src += _overlayscreen->pitch; + buf += pitch; + } while (--h); + + SDL_UnlockSurface(_overlayscreen); +} + +void OSystem_GP2X::copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h) { + assert (_transactionMode == kTransactionNone); + + if (_overlayscreen == NULL) + return; + + // Clip the coordinates + if (x < 0) { + w += x; + buf -= x; + x = 0; + } + + if (y < 0) { + h += y; buf -= y * pitch; + y = 0; + } + + if (w > _overlayWidth - x) { + w = _overlayWidth - x; + } + + if (h > _overlayHeight - y) { + h = _overlayHeight - y; + } + + if (w <= 0 || h <= 0) + return; + + // Mark the modified region as dirty + _cksumValid = false; + addDirtyRect(x, y, w, h); + + if (SDL_LockSurface(_overlayscreen) == -1) + error("SDL_LockSurface failed: %s", SDL_GetError()); + + byte *dst = (byte *)_overlayscreen->pixels + y * _overlayscreen->pitch + x * 2; + do { + memcpy(dst, buf, w * 2); + dst += _overlayscreen->pitch; + buf += pitch; + } while (--h); + + SDL_UnlockSurface(_overlayscreen); +} + +OverlayColor OSystem_GP2X::RGBToColor(uint8 r, uint8 g, uint8 b) { + return SDL_MapRGB(_overlayscreen->format, r, g, b); +} + +void OSystem_GP2X::colorToRGB(OverlayColor color, uint8 &r, uint8 &g, uint8 &b) { + SDL_GetRGB(color, _overlayscreen->format, &r, &g, &b); +} + + +#pragma mark - +#pragma mark --- Mouse --- +#pragma mark - + +bool OSystem_GP2X::showMouse(bool visible) { + if (_mouseVisible == visible) + return visible; + + bool last = _mouseVisible; + _mouseVisible = visible; + + //updateScreen(); + + return last; +} + +void OSystem_GP2X::setMousePos(int x, int y) { + if (x != _mouseCurState.x || y != _mouseCurState.y) { + _mouseCurState.x = x; + _mouseCurState.y = y; + //updateScreen(); + } +} + +void OSystem_GP2X::warpMouse(int x, int y) { + int y1 = y; + + if (_adjustAspectRatio && !_overlayVisible) + y1 = real2Aspect(y); + + if (_mouseCurState.x != x || _mouseCurState.y != y) { + if (!_overlayVisible) + SDL_WarpMouse(x * _scaleFactor, y1 * _scaleFactor); + else + SDL_WarpMouse(x, y1); + + // SDL_WarpMouse() generates a mouse movement event, so + // setMousePos() would be called eventually. However, the + // cannon script in CoMI calls this function twice each time + // the cannon is reloaded. Unless we update the mouse position + // immediately the second call is ignored, causing the cannon + // to change its aim. + + setMousePos(x, y); + } +} + +void OSystem_GP2X::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor, int cursorTargetScale) { + if (w == 0 || h == 0) + return; + + _mouseCurState.hotX = hotspot_x; + _mouseCurState.hotY = hotspot_y; + + _mouseKeyColor = keycolor; + + _cursorTargetScale = cursorTargetScale; + + if (_mouseCurState.w != (int)w || _mouseCurState.h != (int)h) { + _mouseCurState.w = w; + _mouseCurState.h = h; + + if (_mouseOrigSurface) + SDL_FreeSurface(_mouseOrigSurface); + + // Allocate bigger surface because AdvMame2x adds black pixel at [0,0] + _mouseOrigSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, + _mouseCurState.w + 2, + _mouseCurState.h + 2, + 16, + _hwscreen->format->Rmask, + _hwscreen->format->Gmask, + _hwscreen->format->Bmask, + _hwscreen->format->Amask); + + if (_mouseOrigSurface == NULL) + error("allocating _mouseOrigSurface failed"); + SDL_SetColorKey(_mouseOrigSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kMouseColorKey); + } + + free(_mouseData); + + _mouseData = (byte *)malloc(w * h); + memcpy(_mouseData, buf, w * h); + blitCursor(); +} + +void OSystem_GP2X::blitCursor() { + byte *dstPtr; + const byte *srcPtr = _mouseData; + byte color; + int w, h, i, j; + + if (!_mouseOrigSurface || !_mouseData) + return; + + w = _mouseCurState.w; + h = _mouseCurState.h; + + SDL_LockSurface(_mouseOrigSurface); + + // Make whole surface transparent + for (i = 0; i < h + 2; i++) { + dstPtr = (byte *)_mouseOrigSurface->pixels + _mouseOrigSurface->pitch * i; + for (j = 0; j < w + 2; j++) { + *(uint16 *)dstPtr = kMouseColorKey; + dstPtr += 2; + } + } + + // Draw from [1,1] since AdvMame2x adds artefact at 0,0 + dstPtr = (byte *)_mouseOrigSurface->pixels + _mouseOrigSurface->pitch + 2; + + SDL_Color *palette; + + if (_cursorPaletteDisabled) + palette = _currentPalette; + else + palette = _cursorPalette; + + for (i = 0; i < h; i++) { + for (j = 0; j < w; j++) { + color = *srcPtr; + if (color != _mouseKeyColor) { // transparent, don't draw + *(uint16 *)dstPtr = SDL_MapRGB(_mouseOrigSurface->format, + palette[color].r, palette[color].g, palette[color].b); + } + dstPtr += 2; + srcPtr++; + } + dstPtr += _mouseOrigSurface->pitch - w * 2; + } + + int rW, rH; + + if (_cursorTargetScale >= _scaleFactor) { + // The cursor target scale is greater or equal to the scale at + // which the rest of the screen is drawn. We do not downscale + // the cursor image, we draw it at its original size. It will + // appear too large on screen. + + rW = w; + rH = h; + _mouseCurState.rHotX = _mouseCurState.hotX; + _mouseCurState.rHotY = _mouseCurState.hotY; + + // The virtual dimensions may be larger than the original. + + _mouseCurState.vW = w * _cursorTargetScale / _scaleFactor; + _mouseCurState.vH = h * _cursorTargetScale / _scaleFactor; + _mouseCurState.vHotX = _mouseCurState.hotX * _cursorTargetScale / + _scaleFactor; + _mouseCurState.vHotY = _mouseCurState.hotY * _cursorTargetScale / + _scaleFactor; + } else { + // The cursor target scale is smaller than the scale at which + // the rest of the screen is drawn. We scale up the cursor + // image to make it appear correct. + + rW = w * _scaleFactor / _cursorTargetScale; + rH = h * _scaleFactor / _cursorTargetScale; + _mouseCurState.rHotX = _mouseCurState.hotX * _scaleFactor / + _cursorTargetScale; + _mouseCurState.rHotY = _mouseCurState.hotY * _scaleFactor / + _cursorTargetScale; + + // The virtual dimensions will be the same as the original. + + _mouseCurState.vW = w; + _mouseCurState.vH = h; + _mouseCurState.vHotX = _mouseCurState.hotX; + _mouseCurState.vHotY = _mouseCurState.hotY; + } + + int rH1 = rH; // store original to pass to aspect-correction function later + if (_adjustAspectRatio && _cursorTargetScale == 1) { + rH = real2Aspect(rH - 1) + 1; + _mouseCurState.rHotY = real2Aspect(_mouseCurState.rHotY); + } + + if (_mouseCurState.rW != rW || _mouseCurState.rH != rH) { + _mouseCurState.rW = rW; + _mouseCurState.rH = rH; + + if (_mouseSurface) + SDL_FreeSurface(_mouseSurface); + + _mouseSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, + _mouseCurState.rW, + _mouseCurState.rH, + 16, + _hwscreen->format->Rmask, + _hwscreen->format->Gmask, + _hwscreen->format->Bmask, + _hwscreen->format->Amask); + + if (_mouseSurface == NULL) + error("allocating _mouseSurface failed"); + + SDL_SetColorKey(_mouseSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kMouseColorKey); + } + + SDL_LockSurface(_mouseSurface); + + ScalerProc *scalerProc; + + // If possible, use the same scaler for the cursor as for the rest of + // the game. This only works well with the non-blurring scalers so we + // actually only use the 1x, 1.5x, 2x and AdvMame scalers. + + if (_cursorTargetScale == 1 && (_mode == GFX_DOUBLESIZE || _mode == GFX_TRIPLESIZE)) + scalerProc = _scalerProc; + else + scalerProc = scalersMagn[_cursorTargetScale - 1][_scaleFactor - 1]; + + scalerProc((byte *)_mouseOrigSurface->pixels + _mouseOrigSurface->pitch + 2, + _mouseOrigSurface->pitch, (byte *)_mouseSurface->pixels, _mouseSurface->pitch, + _mouseCurState.w, _mouseCurState.h); + + if (_adjustAspectRatio && _cursorTargetScale == 1) + cursorStretch200To240((uint8 *)_mouseSurface->pixels, _mouseSurface->pitch, rW, rH1, 0, 0, 0); + + SDL_UnlockSurface(_mouseSurface); + SDL_UnlockSurface(_mouseOrigSurface); +} + +// Basically it is kVeryFastAndUglyAspectMode of stretch200To240 from +// common/scale/aspect.cpp +static int cursorStretch200To240(uint8 *buf, uint32 pitch, int width, int height, int srcX, int srcY, int origSrcY) { + int maxDstY = real2Aspect(origSrcY + height - 1); + int y; + const uint8 *startSrcPtr = buf + srcX * 2 + (srcY - origSrcY) * pitch; + uint8 *dstPtr = buf + srcX * 2 + maxDstY * pitch; + + for (y = maxDstY; y >= srcY; y--) { + const uint8 *srcPtr = startSrcPtr + aspect2Real(y) * pitch; + + if (srcPtr == dstPtr) + break; + memcpy(dstPtr, srcPtr, width * 2); + dstPtr -= pitch; + } + + return 1 + maxDstY - srcY; +} + +void OSystem_GP2X::undrawMouse() { + const int x = _mouseBackup.x; + const int y = _mouseBackup.y; + + // When we switch bigger overlay off mouse jumps. Argh! + // This is intended to prevent undrawing offscreen mouse + if (!_overlayVisible && (x >= _screenWidth || y >= _screenHeight)) { + return; + } + + if (_mouseBackup.w != 0 && _mouseBackup.h != 0) + addDirtyRect(x, y, _mouseBackup.w, _mouseBackup.h); +} + +void OSystem_GP2X::drawMouse() { + if (!_mouseVisible || !_mouseSurface) { + _mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0; + return; + } + + SDL_Rect zoomdst; + SDL_Rect dst; + int scale; + int width, height; + int hotX, hotY; + int tmpScreenWidth, tmpScreenHeight; + + // Temp vars to ensure we zoom to the LCD resolution or greater. + tmpScreenWidth = _screenWidth; + tmpScreenHeight = _screenHeight; + + if (_screenHeight <= 240) { + tmpScreenHeight = 240; + } + + if (_screenWidth <= 320) { + tmpScreenWidth = 320; + } + + dst.x = _mouseCurState.x; + dst.y = _mouseCurState.y; + + if (!_overlayVisible) { + scale = _scaleFactor; + width = _screenWidth; + height = _screenHeight; + dst.w = _mouseCurState.vW; + dst.h = _mouseCurState.vH; + hotX = _mouseCurState.vHotX; + hotY = _mouseCurState.vHotY; + } else { + scale = 1; + width = _overlayWidth; + height = _overlayHeight; + dst.w = _mouseCurState.rW; + dst.h = _mouseCurState.rH; + hotX = _mouseCurState.rHotX; + hotY = _mouseCurState.rHotY; + } + + // The mouse is undrawn using virtual coordinates, i.e. they may be + // scaled and aspect-ratio corrected. + + _mouseBackup.x = dst.x - hotX; + _mouseBackup.y = dst.y - hotY; + _mouseBackup.w = dst.w; + _mouseBackup.h = dst.h; + + // We draw the pre-scaled cursor image, so now we need to adjust for + // scaling, shake position and aspect ratio correction manually. + + if (!_overlayVisible) { + dst.y += _currentShakePos; + } + + if (_adjustAspectRatio && !_overlayVisible) + dst.y = real2Aspect(dst.y); + + dst.x = scale * dst.x - _mouseCurState.rHotX; + dst.y = scale * dst.y - _mouseCurState.rHotY; + dst.w = _mouseCurState.rW; + dst.h = _mouseCurState.rH; + + // Hacking about with the zoom around mouse pointer stuff. + + if (_adjustZoomOnMouse == true){ + + zoomdst.w = (tmpScreenWidth / 2); + zoomdst.h = (tmpScreenHeight / 2); + + // Create a zoomed rect centered on the mouse pointer. + // Will pan 1/4 of the screen. + + if (dst.x > ((tmpScreenWidth / 4) * 3)) { + zoomdst.x = (tmpScreenWidth / 2); + } else { + zoomdst.x = (dst.x - (tmpScreenWidth / 4)); + if (zoomdst.x < 0) { + zoomdst.x = 0; + } + } + + if (dst.y > ((tmpScreenHeight / 4) * 3)) { + zoomdst.y = (tmpScreenHeight / 2); + } else { + zoomdst.y = (dst.y - (tmpScreenHeight / 4)); + if (zoomdst.y < 0) { + zoomdst.y = 0; + } + } + SDL_GP2X_Display(&zoomdst); + } else { + + // Make sure we are looking at the whole screen otherwise. + + zoomdst.x = 0; + zoomdst.y = 0; + zoomdst.w = (tmpScreenWidth); + zoomdst.h = (tmpScreenHeight); + + SDL_GP2X_Display(&zoomdst); + + }; + + + // Note that SDL_BlitSurface() and addDirtyRect() will both perform any + // clipping necessary + + if (SDL_BlitSurface(_mouseSurface, NULL, _hwscreen, &dst) != 0) + error("SDL_BlitSurface failed: %s", SDL_GetError()); + + // The screen will be updated using real surface coordinates, i.e. + // they will not be scaled or aspect-ratio corrected. + + addDirtyRect(dst.x, dst.y, dst.w, dst.h, true); +} + +#pragma mark - +#pragma mark --- On Screen Display --- +#pragma mark - + +void OSystem_GP2X::displayMessageOnOSD(const char *msg) { + assert (_transactionMode == kTransactionNone); + assert(msg); + + uint i; + + // Lock the OSD surface for drawing + if (SDL_LockSurface(_osdSurface)) + error("displayMessageOnOSD: SDL_LockSurface failed: %s", SDL_GetError()); + + Graphics::Surface dst; + dst.pixels = _osdSurface->pixels; + dst.w = _osdSurface->w; + dst.h = _osdSurface->h; + dst.pitch = _osdSurface->pitch; + dst.bytesPerPixel = _osdSurface->format->BytesPerPixel; + + // The font we are going to use: + const Graphics::Font *font = FontMan.getFontByUsage(Graphics::FontManager::kOSDFont); + + // Clear everything with the "transparent" color, i.e. the colorkey + SDL_FillRect(_osdSurface, 0, kOSDColorKey); + + // Split the message into separate lines. + Common::StringList lines; + const char *ptr; + for (ptr = msg; *ptr; ++ptr) { + if (*ptr == '\n') { + lines.push_back(Common::String(msg, ptr - msg)); + msg = ptr + 1; + } + } + lines.push_back(Common::String(msg, ptr - msg)); + + // Determine a rect which would contain the message string (clipped to the + // screen dimensions). + const int vOffset = 6; + const int lineSpacing = 1; + const int lineHeight = font->getFontHeight() + 2 * lineSpacing; + int width = 0; + int height = lineHeight * lines.size() + 2 * vOffset; + for (i = 0; i < lines.size(); i++) { + width = MAX(width, font->getStringWidth(lines[i]) + 14); + } + + // Clip the rect + if (width > dst.w) + width = dst.w; + if (height > dst.h) + height = dst.h; + + // Draw a dark gray rect + // TODO: Rounded corners ? Border? + SDL_Rect osdRect; + osdRect.x = (dst.w - width) / 2; + osdRect.y = (dst.h - height) / 2; + osdRect.w = width; + osdRect.h = height; + SDL_FillRect(_osdSurface, &osdRect, SDL_MapRGB(_osdSurface->format, 64, 64, 64)); + + // Render the message, centered, and in white + for (i = 0; i < lines.size(); i++) { + font->drawString(&dst, lines[i], + osdRect.x, osdRect.y + i * lineHeight + vOffset + lineSpacing, osdRect.w, + SDL_MapRGB(_osdSurface->format, 255, 255, 255), + Graphics::kTextAlignCenter); + } + + // Finished drawing, so unlock the OSD surface again + SDL_UnlockSurface(_osdSurface); + + // Init the OSD display parameters, and the fade out + _osdAlpha = SDL_ALPHA_TRANSPARENT + kOSDInitialAlpha * (SDL_ALPHA_OPAQUE - SDL_ALPHA_TRANSPARENT) / 100; + _osdFadeStartTime = SDL_GetTicks() + kOSDFadeOutDelay; + SDL_SetAlpha(_osdSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, _osdAlpha); + + // Ensure a full redraw takes place next time the screen is updated + _forceFull = true; +} + +#pragma mark - +#pragma mark --- Misc --- +#pragma mark - + +void OSystem_GP2X::handleScalerHotkeys(const SDL_KeyboardEvent &key) { + // Ctrl-Alt-a toggles aspect ratio correction + if (key.keysym.sym == 'a') { + setFeatureState(kFeatureAspectRatioCorrection, !_adjustAspectRatio); + + char buffer[128]; + if (_adjustAspectRatio) + sprintf(buffer, "Enabled aspect ratio correction\n%d x %d -> %d x %d", + _screenWidth, _screenHeight, + _hwscreen->w, _hwscreen->h + ); + else + sprintf(buffer, "Disabled aspect ratio correction\n%d x %d -> %d x %d", + _screenWidth, _screenHeight, + _hwscreen->w, _hwscreen->h + ); + displayMessageOnOSD(buffer); + + + return; + } + + int newMode = -1; + int factor = _scaleFactor - 1; + + // Increase/decrease the scale factor + if (key.keysym.sym == SDLK_EQUALS || key.keysym.sym == SDLK_PLUS || key.keysym.sym == SDLK_MINUS || + key.keysym.sym == SDLK_KP_PLUS || key.keysym.sym == SDLK_KP_MINUS) { + factor += (key.keysym.sym == SDLK_MINUS || key.keysym.sym == SDLK_KP_MINUS) ? -1 : +1; + if (0 <= factor && factor <= 3) { + newMode = s_gfxModeSwitchTable[_scalerType][factor]; + } + } + + const bool isNormalNumber = (SDLK_1 <= key.keysym.sym && key.keysym.sym <= SDLK_9); + const bool isKeypadNumber = (SDLK_KP1 <= key.keysym.sym && key.keysym.sym <= SDLK_KP9); + if (isNormalNumber || isKeypadNumber) { + _scalerType = key.keysym.sym - (isNormalNumber ? SDLK_1 : SDLK_KP1); + if (_scalerType >= ARRAYSIZE(s_gfxModeSwitchTable)) + return; + + while (s_gfxModeSwitchTable[_scalerType][factor] < 0) { + assert(factor > 0); + factor--; + } + newMode = s_gfxModeSwitchTable[_scalerType][factor]; + } + + if (newMode >= 0) { + setGraphicsMode(newMode); + + if (_osdSurface) { + const char *newScalerName = 0; + const GraphicsMode *g = getSupportedGraphicsModes(); + while (g->name) { + if (g->id == _mode) { + newScalerName = g->description; + break; + } + g++; + } + if (newScalerName) { + char buffer[128]; + sprintf(buffer, "Active graphics filter: %s\n%d x %d -> %d x %d", + newScalerName, + _screenWidth, _screenHeight, + _hwscreen->w, _hwscreen->h + ); + displayMessageOnOSD(buffer); + } + } + + } + +} diff --git a/backends/platform/gp2x/module.mk b/backends/platform/gp2x/module.mk new file mode 100644 index 0000000000..34c7d79501 --- /dev/null +++ b/backends/platform/gp2x/module.mk @@ -0,0 +1,15 @@ +MODULE := backends/platform/gp2x + +MODULE_OBJS := \ + gp2x-hw.o \ + gp2x-mem.o \ + events.o \ + graphics.o \ + gp2x.o + # overload_help.o + +MODULE_DIRS += \ + backends/platform/gp2x/ + +# We don't use the common.rules here on purpose +OBJS := $(addprefix $(MODULE)/, $(MODULE_OBJS)) $(OBJS) diff --git a/common/config-manager.cpp b/common/config-manager.cpp index 354a48e031..0f80e5c84f 100644 --- a/common/config-manager.cpp +++ b/common/config-manager.cpp @@ -89,7 +89,7 @@ ConfigManager::ConfigManager() void ConfigManager::loadDefaultConfigFile() { char configFile[MAXPATHLEN]; -#if defined(UNIX) +#if defined(UNIX) && !defined(GP2X) // GP2X is Linux based but Home dir can be read only so do not use it and put the config in the executable dir. const char *home = getenv("HOME"); if (home != NULL && strlen(home) < MAXPATHLEN) snprintf(configFile, MAXPATHLEN, "%s/%s", home, DEFAULT_CONFIG_FILE); @@ -335,7 +335,7 @@ void ConfigManager::writeDomain(FILE *file, const String &name, const Domain &do const ConfigManager::Domain *ConfigManager::getDomain(const String &domName) const { assert(!domName.empty()); assert(isValidDomainName(domName)); - + if (domName == kTransientDomain) return &_transientDomain; if (domName == kApplicationDomain) @@ -349,7 +349,7 @@ const ConfigManager::Domain *ConfigManager::getDomain(const String &domName) con ConfigManager::Domain *ConfigManager::getDomain(const String &domName) { assert(!domName.empty()); assert(isValidDomainName(domName)); - + if (domName == kTransientDomain) return &_transientDomain; if (domName == kApplicationDomain) @@ -527,7 +527,7 @@ void ConfigManager::set(const String &key, const String &value, const String &do key.c_str(), value.c_str(), domName.c_str()); (*domain)[key] = value; - + // TODO/FIXME: We used to erase the given key from the transient domain // here. Do we still want to do that? // It was probably there to simplify the options dialogs code: diff --git a/configure b/configure index e558a6328c..2a5cf0ba8c 100755 --- a/configure +++ b/configure @@ -303,7 +303,7 @@ Usage: $0 [OPTIONS]... Configuration: -h, --help display this help and exit - --backend=BACKEND backend to build (sdl, x11, morphos, dc, gp32, null) [sdl] + --backend=BACKEND backend to build (sdl, x11, morphos, dc, gp32, gp2x, null) [sdl] Installation directories: --prefix=DIR use this prefix for installing ScummVM [/usr/local] @@ -527,6 +527,10 @@ ppc-amigaos) _host_os=amigaos _host_cpu=ppc ;; +gp2x) + _host_os=gp2x-linux + _host_cpu=arm + ;; *) guessed_host=`$_srcdir/config.guess` _host_cpu=`echo $guessed_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` @@ -545,6 +549,9 @@ mingw* | cygwin* | os2-emx*) arm-riscos) EXEEXT=",ff8" ;; +gp2x-linux) + EXEEXT=".gpe" + ;; *) EXEEXT="" ;; @@ -704,6 +711,18 @@ if test -n "$_host"; then type_2_byte='short' type_4_byte='int' ;; + gp2x) + echo "Cross-compiling to $_host, forcing endianness, alignment and type sizes" + DEFINES="$DEFINES -DUNIX -DGP2X" + _def_endianness='#define SCUMM_LITTLE_ENDIAN' + _def_align='#define SCUMM_NEED_ALIGNMENT' + type_1_byte='char' + type_2_byte='short' + type_4_byte='int' + _backend="gp2x" + _mak_hq_scalers='DISABLE_HQ_SCALERS = 1' + _build_hq_scalers="no" + ;; ppc-amigaos) echo "Cross-compiling to $_host, forcing endianness, alignment and type sizes" _def_endianness='#define SCUMM_BIG_ENDIAN' @@ -1288,6 +1307,14 @@ case $_backend in LIBS="$LIBS `$_sdlconfig --libs`" MODULES="$MODULES backends/platform/sdl" ;; + gp2x) + find_sdlconfig + INCLUDES="$INCLUDES `$_sdlconfig --cflags`" + LIBS="$LIBS `$_sdlconfig --libs`" + LDFLAGS="$LDFLAGS -static" + CXXFLAGS="$CXXFLAGS -march=armv4t" + MODULES="$MODULES backends/platform/gp2x" + ;; x11) INCLUDES="$INCLUDES -I/usr/X11R6/include" LIBS="$LIBS -lpthread -lXext -lX11" diff --git a/sound/fmopl.cpp b/sound/fmopl.cpp index c5705e01b7..9fd8a33ee4 100644 --- a/sound/fmopl.cpp +++ b/sound/fmopl.cpp @@ -35,7 +35,7 @@ #include "common/util.h" -#if defined (_WIN32_WCE) || defined (__SYMBIAN32__) || defined(PALMOS_MODE) || defined(__GP32__) || defined (__MAEMO__) || defined(__DS__) +#if defined (_WIN32_WCE) || defined (__SYMBIAN32__) || defined(PALMOS_MODE) || defined(__GP32__) || defined(__GP2X__) || defined (__MAEMO__) || defined(__DS__) #include "common/config-manager.h" #endif @@ -477,7 +477,7 @@ inline void OPL_CALC_CH(OPL_CH *CH) { env_out=OPL_CALC_SLOT(SLOT); if(env_out < (uint)(EG_ENT - 1)) { /* PG */ - if(SLOT->vib) + if(SLOT->vib) SLOT->Cnt += (SLOT->Incr * vib / VIB_RATE); else SLOT->Cnt += SLOT->Incr; @@ -512,7 +512,7 @@ inline void OPL_CALC_CH(OPL_CH *CH) { inline void OPL_CALC_RH(OPL_CH *CH) { uint env_tam, env_sd, env_top, env_hh; int whitenoise = int(oplRnd.getRandomNumber(1) * (WHITE_NOISE_db / EG_STEP)); - + int tone8; OPL_SLOT *SLOT; @@ -609,7 +609,7 @@ static void init_timetables(FM_OPL *OPL, int ARRATE, int DRRATE) { OPL->AR_TABLE[i] = OPL->DR_TABLE[i] = 0; for (i = 4; i <= 60; i++) { rate = OPL->freqbase; /* frequency rate */ - if(i < 60) + if(i < 60) rate *= 1.0 + (i & 3) * 0.25; /* b0-1 : x1 , x1.25 , x1.5 , x1.75 */ rate *= 1 << ((i >> 2) - 1); /* b2-5 : shift bit */ rate *= (double)(EG_ENT << ENV_BITS); @@ -1177,7 +1177,7 @@ FM_OPL *makeAdlibOPL(int rate) { // We need to emulate one YM3812 chip int env_bits = FMOPL_ENV_BITS_HQ; int eg_ent = FMOPL_EG_ENT_HQ; -#if defined (_WIN32_WCE) || defined(__SYMBIAN32__) || defined(PALMOS_MODE) || defined(__GP32__) || defined(__MAEMO__) || defined(__DS__) +#if defined (_WIN32_WCE) || defined(__SYMBIAN32__) || defined(PALMOS_MODE) || defined(__GP32__) || defined (GP2X) || defined(__MAEMO__) || defined(__DS__) if (ConfMan.hasKey("FM_high_quality") && ConfMan.getBool("FM_high_quality")) { env_bits = FMOPL_ENV_BITS_HQ; eg_ent = FMOPL_EG_ENT_HQ; -- cgit v1.2.3