diff options
Diffstat (limited to 'backends/epoc/src/SymbianOS.cpp')
| -rw-r--r-- | backends/epoc/src/SymbianOS.cpp | 400 |
1 files changed, 400 insertions, 0 deletions
diff --git a/backends/epoc/src/SymbianOS.cpp b/backends/epoc/src/SymbianOS.cpp new file mode 100644 index 0000000000..6a775957d4 --- /dev/null +++ b/backends/epoc/src/SymbianOS.cpp @@ -0,0 +1,400 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003-2005 Andreas 'Sprawl' Karlsson - Original EPOC port, ESDL + * Copyright (C) 2003-2005 Lars 'AnotherGuest' Persson - Original EPOC port, Audio System + * Copyright (C) 2005 Jurgen 'SumthinWicked' Braam - EPOC/CVS maintainer + * Copyright (C) 2005 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + */ + +#include "backends/epoc/src/SymbianOS.h" +#include "backends/epoc/src/SymbianActions.h" +#include "gui/Actions.h" +#include "gui/Key.h" +#include "gui/message.h" + +#include <eikenv.h> // for CEikonEnv::Static() @ SymbianFatalError() + +#include "common/config-manager.h" + +extern Common::ConfigManager *g_config; + +static const OSystem::GraphicsMode s_supportedGraphicsModes[] = { + {"1x", "Fullscreen", GFX_NORMAL}, + {0, 0, 0} +}; + +OSystem *OSystem_SymbianOS_create() { + return new OSystem_SDL_Symbian(); +} + +// Show a simple Symbian Info win with Msg & exit +void SymbianFatalError(const char *msg) { + TPtrC8 msgPtr((const TUint8 *)msg); + TBuf<512> msg16Bit; + msg16Bit.Copy(msgPtr); + CEikonEnv::Static()->InfoWinL(_L("ScummVM Fatal Error"), msg16Bit); + + if (g_system) + g_system->quit(); +} + +bool OSystem_SDL_Symbian::hasFeature(Feature f) { + switch(f) { + case kFeatureFullscreenMode: + case kFeatureAspectRatioCorrection: + case kFeatureAutoComputeDirtyRects: + case kFeatureCursorHasPalette: +#ifdef USE_VIBRA_SE_PXXX + case kFeatureVibration: +#endif + return true; + + default: + return false; + } +} + +OSystem_SDL_Symbian::zoneDesc OSystem_SDL_Symbian::_zones[TOTAL_ZONES] = { + { 0, 0, 320, 145 }, + { 0, 145, 150, 55 }, + { 150, 145, 170, 55 } +}; +OSystem_SDL_Symbian::OSystem_SDL_Symbian() :_channels(0),_stereo_mix_buffer(0) +{ + ConfMan.set("FM_high_quality", false); +#ifndef S60 // S60 has low quality as default + ConfMan.set("FM_medium_quality", true); +#else + ConfMan.set("FM_medium_quality", false); +#endif + ConfMan.set("joystick_num", 0); // Symbian OS should have joystick_num set to 0 in the ini file , but uiq devices might refuse opening the joystick + ConfMan.flushToDisk(); + // Initialize global key mapping for Smartphones + GUI::Actions* actions = GUI::Actions::Instance(); + actions->initInstanceMain(this); + actions->loadMapping(); + initZones(); +} + +OSystem_SDL_Symbian::~OSystem_SDL_Symbian() { + delete []_stereo_mix_buffer; +} + +int OSystem_SDL_Symbian::getDefaultGraphicsMode() const { + return GFX_NORMAL; +} + +const OSystem::GraphicsMode *OSystem_SDL_Symbian::getSupportedGraphicsModes() const { + return s_supportedGraphicsModes; +} + +// make sure we always go to normal, even if the string might be set wrong! +bool OSystem_SDL_Symbian::setGraphicsMode(const char * /*name*/) { + // let parent OSystem_SDL handle it + return OSystem_SDL::setGraphicsMode(getDefaultGraphicsMode()); +} + +void OSystem_SDL_Symbian::quitWithErrorMsg(const char *msg) { + + CEikonEnv::Static()->AlertWin(_L("quitWithErrorMsg()")) ; + + if (g_system) + g_system->quit(); +} + +/* + * SumthinWicked says: the stuff below is copied from common/scaler.cpp, + * so we can skip compiling the scalers. ESDL still needs 1x and the scaler + * architecture because we inherit from OSystem_SDL. + */ +int gBitFormat = 565; +void InitScalers(uint32 /*BitFormat*/) {} // called by OSystem_SDL functions, not relevant for ESDL + +/** + * Trivial 'scaler' - in fact it doesn't do any scaling but just copies the + * source to the destination. + */ +void Normal1x(const uint8 *srcPtr, uint32 srcPitch, uint8 *dstPtr, uint32 dstPitch, + int width, int height) { + while (height--) { + memcpy(dstPtr, srcPtr, 2 * width); + srcPtr += srcPitch; + dstPtr += dstPitch; + } +} + +bool OSystem_SDL_Symbian::setSoundCallback(SoundProc proc, void *param) { + + // First save the proc and param + _sound_proc_param = param; + _sound_proc = proc; + 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; + + // Originally, we always used 2048 samples. This loop will produce the + // same result at 22050 Hz, and should hopefully produce something + // sensible for other frequencies. Note that it must be a power of two. + + uint32 samples = 0x8000; + + for (;;) { + if ((1000 * samples) / _samplesPerSec < 100) + break; + samples >>= 1; + } + + desired.freq = _samplesPerSec; + desired.format = AUDIO_S16SYS; + desired.channels = 2; + desired.samples = (uint16)samples; +#ifdef S60 + desired.callback = symbianMixCallback; + desired.userdata = this; +#else + desired.callback = proc; + desired.userdata = param; +#endif + if (SDL_OpenAudio(&desired, &obtained) != 0) { + warning("Could not open audio device: %s", SDL_GetError()); + return false; + } + // Note: This should be the obtained output rate, but it seems that at + // least on some platforms SDL will lie and claim it did get the rate + // even if it didn't. Probably only happens for "weird" rates, though. + _samplesPerSec = obtained.freq; + _channels = obtained.channels; + + // Need to create mixbuffer for stereo mix to downmix + if(_channels != 2) { + _stereo_mix_buffer = new byte [obtained.size*2];//*2 for stereo values + } + + SDL_PauseAudio(0); + return true; +} + +/** + * The mixer callback function, passed on to OSystem::setSoundCallback(). + * This simply calls the mix() method. + */ +void OSystem_SDL_Symbian::symbianMixCallback(void *s, byte *samples, int len) { + static_cast <OSystem_SDL_Symbian*>(s)->symbianMix(samples,len); +} + + +/** + * Actual mixing implementation + */ +void OSystem_SDL_Symbian::symbianMix(byte *samples, int len) { + // If not stereo then we need to downmix + if (_channels != 2) { + _sound_proc(_sound_proc_param, _stereo_mix_buffer, len * 2); + int16 *bitmixDst = (int16 *)samples; + int16 *bitmixSrc = (int16 *)_stereo_mix_buffer; + + for (int loop = len / 2; loop >= 0; loop --) { + *bitmixDst = (*bitmixSrc + *(bitmixSrc + 1)) >> 1; + bitmixDst++; + bitmixSrc += 2; + } + } else + _sound_proc(_sound_proc_param, samples, len); +} + +/** + * This is an implementation by the remapKey function + * @param SDL_Event to remap + * @param ScumVM event to modify if special result is requested + * @return true if Event has a valid return status + */ +bool OSystem_SDL_Symbian::remapKey(SDL_Event &ev, Event &event) { + if (GUI::Actions::Instance()->mappingActive() || ev.key.keysym.sym <= SDLK_UNKNOWN) + return false; + + for (TInt loop = 0; loop < GUI::ACTION_LAST; loop++) { + if (GUI::Actions::Instance()->getMapping(loop) == ev.key.keysym.sym && + GUI::Actions::Instance()->isEnabled(loop)) { + // Create proper event instead + switch(loop) { + case GUI::ACTION_UP: + if (ev.type == SDL_KEYDOWN) { + _km.y_vel = -1; + _km.y_down_count = 1; + } else { + _km.y_vel = 0; + _km.y_down_count = 0; + } + event.type = EVENT_MOUSEMOVE; + fillMouseEvent(event, _km.x, _km.y); + + return true; + + case GUI::ACTION_DOWN: + if(ev.type == SDL_KEYDOWN) { + _km.y_vel = 1; + _km.y_down_count = 1; + } else { + _km.y_vel = 0; + _km.y_down_count = 0; + } + event.type = EVENT_MOUSEMOVE; + fillMouseEvent(event, _km.x, _km.y); + + return true; + + case GUI::ACTION_LEFT: + if(ev.type == SDL_KEYDOWN) { + _km.x_vel = -1; + _km.x_down_count = 1; + } else { + _km.x_vel = 0; + _km.x_down_count = 0; + } + event.type = EVENT_MOUSEMOVE; + fillMouseEvent(event, _km.x, _km.y); + + return true; + + case GUI::ACTION_RIGHT: + if(ev.type == SDL_KEYDOWN) { + _km.x_vel = 1; + _km.x_down_count = 1; + } else { + _km.x_vel = 0; + _km.x_down_count = 0; + } + event.type = EVENT_MOUSEMOVE; + fillMouseEvent(event, _km.x, _km.y); + + return true; + + case GUI::ACTION_LEFTCLICK: + event.type = (ev.type == SDL_KEYDOWN ? EVENT_LBUTTONDOWN : EVENT_LBUTTONUP); + fillMouseEvent(event, _km.x, _km.y); + + return true; + + case GUI::ACTION_RIGHTCLICK: + event.type = (ev.type == SDL_KEYDOWN ? EVENT_RBUTTONDOWN : EVENT_RBUTTONUP); + fillMouseEvent(event, _km.x, _km.y); + + return true; + + case GUI::ACTION_ZONE: + if(ev.type == SDL_KEYDOWN) { + int i; + + for (i=0; i < TOTAL_ZONES; i++) + if (_km.x >= _zones[i].x && _km.y >= _zones[i].y && + _km.x <= _zones[i].x + _zones[i].width && _km.y <= _zones[i].y + _zones[i].height + ) { + _mouseXZone[i] = _km.x; + _mouseYZone[i] = _km.y; + break; + } + _currentZone++; + if (_currentZone >= TOTAL_ZONES) + _currentZone = 0; + event.type = EVENT_MOUSEMOVE; + fillMouseEvent(event, _mouseXZone[_currentZone], _mouseYZone[_currentZone]); + SDL_WarpMouse(event.mouse.x, event.mouse.y); + } + + return true; + + case GUI::ACTION_SAVE: + case GUI::ACTION_SKIP: + case GUI::ACTION_FT_CHEAT: + case GUI::ACTION_SKIP_TEXT: + case GUI::ACTION_PAUSE: + { + GUI::Key &key = GUI::Actions::Instance()->getKeyAction(loop); + ev.key.keysym.sym = (SDLKey)key.ascii(); + ev.key.keysym.scancode= key.keycode(); + ev.key.keysym.mod = (SDLMod)key.flags(); + + return false; + } + + case GUI::ACTION_QUIT: + { + GUI::MessageDialog alert("Do you want to quit ?", "Yes", "No"); + if (alert.runModal() == GUI::kMessageOK) + quit(); + + return true; + } + } + } + } + + return false; +} + +void OSystem_SDL_Symbian::setWindowCaption(const char *caption) { + OSystem_SDL::setWindowCaption(caption); + check_mappings(); +} + +void OSystem_SDL_Symbian::check_mappings() { + if (!GUI::Actions::Instance()->gameDetector()._targetName.size() || GUI::Actions::Instance()->initialized()) + return; + + GUI::Actions::Instance()->initInstanceGame(); +} + +void OSystem_SDL_Symbian::initZones() { + int i; + + _currentZone = 0; + + for (i = 0; i < TOTAL_ZONES; i++) { + _mouseXZone[i] = (_zones[i].x + (_zones[i].width / 2)); + _mouseYZone[i] = (_zones[i].y + (_zones[i].height / 2)); + } +} + + +/** Vibration support */ +#ifdef USE_VIBRA_SE_PXXX +void OSystem_SDL_Symbian::initializeVibration() { + _vibrationApi = SonyEricsson::CVibration::NewL(); +} + +void OSystem_SDL_Symbian::vibrationOn(int vibraLength) { + // initialize? + if (!_vibrationApi) _vibrationApi = SonyEricsson::CVibration::NewL(); + // do it! + _vibrationApi->VibrationOn(1, 1, vibraLength); +} + +void OSystem_SDL_Symbian::vibrationOff() { + _vibrationApi->VibrationOff(); +} +#endif // USE_SE_PXX_VIBRA + |