Ticket #8349: timer-v6.patch

backends/midi/adlib.cpp

@@ -19 +19 @@
  */
 
 #include "stdafx.h"
+
+#include "common/system.h"
+#include "common/util.h"
+
 #include "sound/mididrv.h"
 #include "sound/fmopl.h"
 #include "sound/mixer.h"
-#include "common/util.h"
 
 #define BASE_FREQ 250
 #define FIXP_SHIFT 16
@@ -559 +562 @@
         void setPitchBendRange(byte channel, uint range); 
         void sysEx_customInstrument(byte channel, uint32 type, byte *instr);
 
-        void setTimerCallback(void *timer_param, Timer::TimerProc timer_proc);
+        void setTimerCallback(void *timer_param, OSystem::TimerProc timer_proc);
         uint32 getBaseTempo() {
                 return 1000000 / BASE_FREQ;
         }
@@ -575 +578 @@
         byte *_adlib_reg_cache;
         SoundMixer *_mixer;
 
-        Timer::TimerProc _timer_proc;
+        OSystem::TimerProc _timer_proc;
         void *_timer_param;
 
         int _adlib_timer_counter;
@@ -964 +967 @@
         _parts[channel].sysEx_customInstrument(type, instr);
 }
 
-void MidiDriver_ADLIB::setTimerCallback(void *timer_param, Timer::TimerProc timer_proc) {
+void MidiDriver_ADLIB::setTimerCallback(void *timer_param, OSystem::TimerProc timer_proc) {
         _timer_proc = timer_proc;
         _timer_param = timer_param;
 }

backends/midi/ym2612.cpp

@@ -23 +23 @@
  */
 
 #include "stdafx.h"
+
+#include "common/system.h"
 #include "common/util.h"
+
 #include "sound/mididrv.h"
 #include "sound/mixer.h"
 
@@ -166 +169 @@
 
         bool _isOpen;
         SoundMixer *_mixer;
-        Timer::TimerProc _timer_proc;
+        OSystem::TimerProc _timer_proc;
         void *_timer_param;
         int _next_tick;
         int _samples_per_tick;
@@ -193 +196 @@
         void setPitchBendRange(byte channel, uint range) { }
         void sysEx(byte *msg, uint16 length);
 
-        void setTimerCallback(void *timer_param, Timer::TimerProc timer_proc);
+        void setTimerCallback(void *timer_param, OSystem::TimerProc timer_proc);
         uint32 getBaseTempo() { return 1000000 / BASE_FREQ; }
 
         MidiChannel *allocateChannel() { return 0; }
@@ -768 +771 @@
         _mixer->setupPremix(0, 0);
 }
 
-void MidiDriver_YM2612::setTimerCallback(void *timer_param, Timer::TimerProc timer_proc) {
+void MidiDriver_YM2612::setTimerCallback(void *timer_param, OSystem::TimerProc timer_proc) {
         _timer_proc = timer_proc;
         _timer_param = timer_param;
 }

backends/sdl/sdl-common.h

@@ -30 +30 @@
 #include "backends/intern.h"
 
 #include <SDL.h>
+#include <SDL_thread.h>
 
 #ifndef _WIN32_WCE
 // Uncomment this to enable the 'on screen display' code.
 #define USE_OSD 1
 #endif
 
+#ifndef OLD_TIMER
 class OSystem_SDL : public OSystem {
+#else
+class OSystem_SDL : public OSystemWithDefaultTimerCode {
+#endif
 public:
         OSystem_SDL();
         virtual ~OSystem_SDL();
@@ -103 +108 @@
         void quit();
 
 
+#ifdef OLD_TIMER
         // Add a callback timer
-        void setTimerCallback(TimerProc callback, int timer);
-
+        void setTimerCallback(TimerCallback callback, int timer);
+#else
+        // Install/Remove callback timer
+        bool installTimerProc(TimerProc procedure, int32 interval, void *refCon);
+        void removeTimerProc(TimerProc procedure);
+#endif
         // Mutex handling
         MutexRef createMutex();
         void lockMutex(MutexRef mutex);
@@ -208 +218 @@
         bool cksum_valid;
         int CKSUM_NUM;
 
+#ifndef OLD_TIMER
+        // Timer Management
+        #define SDL_MAX_TIMERS 5
+        #define THREAD_RUN 0
+        #define THREAD_REMOVE 1
+
+        class TimerSlot {
+        friend class OSystem_SDL;
+        private:
+                TimerProc _threadFunc;
+                SDL_Thread *_threadHandle;
+                int _threadState;
+                double _interval;
+                void *_refCon;
+                double _startTime;
+                double _lastTime;
+
+                bool wait();
+                void thread();
+        public:
+                static int threadHandler(void *slotRef);
+        } _timerSlots[SDL_MAX_TIMERS];
+
+        MutexRef _timerMutex;
+
+        bool createTimer();
+        void deleteTimer();
+        void resetTimerSlot(int slot);
+#endif
+
         // Keyboard mouse emulation
         struct KbdMouse {       
                 int16 x, y, x_vel, y_vel, x_max, y_max, x_down_count, y_down_count;

backends/sdl/sdl.cpp

@@ -81 +81 @@
         setup_icon();
 #endif
 
+#ifndef OLD_TIMER
+        createTimer();
+#endif
+
         // enable joystick
         if (joystick_num > -1 && SDL_NumJoysticks() > 0) {
                 printf("Using joystick: %s\n", SDL_JoystickName(0));
@@ -118 +122 @@
 OSystem_SDL::~OSystem_SDL() {
 //      unload_gfx_mode();
 
+#ifndef OLD_TIMER
+        deleteTimer();
+#endif
+
         if (_dirty_checksums)
                 free(_dirty_checksums);
         free(_currentPalette);
@@ -136 +144 @@
         SDL_Delay(msecs);
 }
 
-void OSystem_SDL::setTimerCallback(TimerProc callback, int timer) {
+#ifdef OLD_TIMER
+void OSystem_SDL::setTimerCallback(TimerCallback callback, int timer) {
         SDL_SetTimer(timer, (SDL_TimerCallback) callback);
 }
+#else
+
+bool OSystem_SDL::createTimer() {
+        _timerMutex = createMutex();
+
+        for (int i = 0; i < SDL_MAX_TIMERS; i++) {
+                resetTimerSlot(i);
+        }
+
+        return true;
+}
+
+void OSystem_SDL::deleteTimer() {
+        {
+                Common::StackLock lock(_timerMutex);
+                for (int i = 0; i < SDL_MAX_TIMERS; i++) {
+                        if (_timerSlots[i]._threadFunc) {
+                                _timerSlots[i]._threadState = THREAD_REMOVE;
+                                SDL_WaitThread(_timerSlots[i]._threadHandle, NULL);
+                                resetTimerSlot(i);
+                        }
+                }
+        }
+
+        deleteMutex(_timerMutex);
+}
+
+void OSystem_SDL::resetTimerSlot(int slot) {
+        _timerSlots[slot]._threadHandle = NULL;
+        _timerSlots[slot]._threadFunc = NULL;
+        _timerSlots[slot]._threadState = THREAD_REMOVE;
+        _timerSlots[slot]._interval = 0.0;
+        _timerSlots[slot]._refCon = NULL;
+        _timerSlots[slot]._startTime = 0.0;
+        _timerSlots[slot]._lastTime = 0.0;
+}
+
+bool OSystem_SDL::installTimerProc(TimerProc procedure, int32 interval, void *refCon) {
+        assert(interval > 0);
+        Common::StackLock lock(_timerMutex);
+
+        for (int i = 0; i < SDL_MAX_TIMERS; i++) {
+                if (!_timerSlots[i]._threadFunc) {
+                        _timerSlots[i]._threadFunc = procedure;
+                        _timerSlots[i]._interval = interval;
+                        _timerSlots[i]._refCon = refCon;
+                        _timerSlots[i]._startTime = SDL_GetTicks() * 1000.0;
+                        _timerSlots[i]._lastTime = _timerSlots[i]._startTime;
+                        _timerSlots[i]._threadState = THREAD_RUN;
+                        _timerSlots[i]._threadHandle = SDL_CreateThread(_timerSlots[i].threadHandler, (void *)&_timerSlots[i]);
+                        if (_timerSlots[i]._threadHandle == NULL) {
+                                resetTimerSlot(i);
+                                warning("SDL Timer, installTimerProc() Couldn't create thread!");
+                                return false;
+                        }
+                        return true;
+                }
+        }
+
+        warning("SDL Timer, installTimerProc() Couldn't find free timer slot!");
+        return false;
+}
+
+void OSystem_SDL::removeTimerProc(TimerProc procedure) {
+        assert(procedure);
+        Common::StackLock lock(_timerMutex);
+
+        for (int i = 0; i < SDL_MAX_TIMERS; i++) {
+                if (_timerSlots[i]._threadFunc == procedure) {
+                        _timerSlots[i]._threadState = THREAD_REMOVE;
+                        SDL_WaitThread(_timerSlots[i]._threadHandle, NULL);
+                        resetTimerSlot(i);
+                }
+        }
+}
+
+bool OSystem_SDL::TimerSlot::wait() {
+        double interval = 0.0;
+
+        if (_threadState == THREAD_REMOVE) {
+                return false;
+        }
+
+        double currentTime = SDL_GetTicks() * 1000.0;
+
+        if ((currentTime - _lastTime) < _interval) {
+                double elapsedTime = (currentTime - _startTime);
+                interval = _interval - (elapsedTime - ((uint32)(elapsedTime / _interval) * _interval));
+        }
+
+        SDL_Delay((uint32)(interval / 1000.0));
+        _lastTime = SDL_GetTicks() * 1000.0;
+
+        return true;
+}
+
+void OSystem_SDL::TimerSlot::thread() {
+        do {
+                (_threadFunc)(_refCon);
+        } while (wait());
+}
+
+int OSystem_SDL::TimerSlot::threadHandler(void *slotRef) {
+        TimerSlot *slot = (TimerSlot *)slotRef;
+        slot->thread();
+        return 0;
+}
+#endif
 
 void OSystem_SDL::setWindowCaption(const char *caption) {
         SDL_WM_SetCaption(caption, caption);

backends/wince/wince-sdl.cpp

@@ -26 +26 @@
 #include "base/gameDetector.h"
 #include "base/engine.h"
 #include "base/plugins.h"
-#include "common/timer.h"
 
 #include "common/config-manager.h"
 

base/engine.cpp

@@ -26 +26 @@
 #include "base/gameDetector.h"
 #include "common/config-manager.h"
 #include "common/file.h"
-#include "common/timer.h"
 #include "sound/mixer.h"
 
 /* FIXME - BIG HACK for MidiEmu */
@@ -39 +38 @@
         g_engine = this;
         _mixer = GameDetector::createMixer();
 
-        _timer = g_timer;
-
         // Add default file directory
         File::addDefaultDirectory(_gameDataPath);
 

base/engine.h

@@ -26 +26 @@
 #include "common/system.h"
 
 class SoundMixer;
-class Timer;
 
 class Engine {
 public:
         OSystem *_system;
         SoundMixer *_mixer;
-        Timer * _timer;
 
 protected:
         const Common::String _gameDataPath;

base/main.cpp

@@ -36 +36 @@
 #include "common/config-manager.h"
 #include "common/file.h"
 #include "common/scaler.h"      // For GFX_NORMAL
-#include "common/timer.h"
 #include "gui/newgui.h"
 #include "gui/launcher.h"
 #include "gui/message.h"
@@ -365 +364 @@
         // at an earlier point, though!)
         OSystem *system = OSystem::instance();
 
-        // Create the timer services
-        g_timer = new Timer(system);
-
         // Set initial window caption
         system->setWindowCaption(gScummVMFullVersion);
 
@@ -394 +390 @@
         //}
 
         // ...and quit (the return 0 should never be reached)
-        delete g_timer;
         system->quit();
         delete system;
         return 0;

common/module.mk

@@ -6 +6 @@
         common/md5.o \
         common/str.o \
         common/stream.o \
-        common/timer.o \
         common/util.o \
         common/savefile.o \
         common/system.o

common/system.cpp

@@ -59 +59 @@
 }
 
 OSystem *OSystem::instance() {
-        if (!s_system)
+        if (!s_system) {
                 s_system = createSystem();
+                assert(s_system);
+                s_system->init();
+        }
         return s_system;
 }
 
@@ -92 +95 @@
         dialog.runModal();
 }
 
+#pragma mark -
+
 SaveFileManager *OSystem::get_savefile_manager() {
         return new DefaultSaveFileManager();
 }
 
+OSystemWithDefaultTimerCode::OSystemWithDefaultTimerCode() {
+        _timerMutex = NULL;
+        _timerCallback = NULL;
+        _timerLastTime = 0;
+}
+
+void OSystemWithDefaultTimerCode::init() {
+        _timerMutex = createMutex();
+
+        for (int i = 0; i < MAX_TIMERS; i++) {
+                _timerSlots[i].procedure = NULL;
+                _timerSlots[i].interval = 0;
+                _timerSlots[i].counter = 0;
+        }
+
+        _timerThisTime = get_msecs();
+
+        // Set the timer last, after everything has been initialised
+        setTimerCallback(&timerCallback, 10);
+}
+
+void OSystemWithDefaultTimerCode::deinit() {
+        // Remove the timer callback.
+        // Note: backends *must* gurantee that after this method call returns,
+        // the handler is not in use anymore; else race condtions could occurs.
+        setTimerCallback(0, 0);
+
+        {
+                Common::StackLock lock(_timerMutex);
+                for (int i = 0; i < MAX_TIMERS; i++) {
+                        _timerSlots[i].procedure = NULL;
+                        _timerSlots[i].interval = 0;
+                        _timerSlots[i].counter = 0;
+                }
+        }
+
+        deleteMutex(_timerMutex);
+}
+
+bool OSystemWithDefaultTimerCode::installTimerProc(TimerProc proc, int32 interval, void *refCon) {
+        assert(interval > 0);
+        Common::StackLock lock(_timerMutex);
+
+        for (int l = 0; l < MAX_TIMERS; l++) {
+                if (!_timerSlots[l].procedure) {
+                        _timerSlots[l].procedure = proc;
+                        _timerSlots[l].interval = interval;
+                        _timerSlots[l].counter = interval;
+                        _timerSlots[l].refCon = refCon;
+                        return true;
+                }
+        }
+
+        warning("Couldn't find free timer slot!");
+        return false;
+}
+
+void OSystemWithDefaultTimerCode::removeTimerProc(TimerProc proc) {
+        Common::StackLock lock(_timerMutex);
+
+        for (int l = 0; l < MAX_TIMERS; l++) {
+                if (_timerSlots[l].procedure == proc) {
+                        _timerSlots[l].procedure = 0;
+                        _timerSlots[l].interval = 0;
+                        _timerSlots[l].counter = 1;     // Work around a problem when a timer proc removes its
+                        _timerSlots[l].refCon = 0;
+                }
+        }
+}
+
+int OSystemWithDefaultTimerCode::timerCallback(int t) {
+        return ((OSystemWithDefaultTimerCode *)g_system)->timerMain(t);
+}
+
+int OSystemWithDefaultTimerCode::timerMain(int t) {
+        Common::StackLock lock(_timerMutex);
+        uint32 interval, l;
+
+        _timerLastTime = _timerThisTime;
+        _timerThisTime = get_msecs();
+        interval = 1000 * (_timerThisTime - _timerLastTime);
+
+        for (l = 0; l < MAX_TIMERS; l++) {
+                if (_timerSlots[l].procedure && _timerSlots[l].interval > 0) {
+                        _timerSlots[l].counter -= interval;
+                        while (_timerSlots[l].counter <= 0) {
+                                // A small paranoia check which catches the case where
+                                // a timer removes itself (which it never should do).
+                                assert(_timerSlots[l].procedure && _timerSlots[l].interval > 0);
+                                _timerSlots[l].counter += _timerSlots[l].interval;
+                                _timerSlots[l].procedure(_timerSlots[l].refCon);
+                        }
+                }
+        }
+
+        return t;
+}
+
 #pragma mark -
 
 

common/system.h

@@ -49 +49 @@
          */
         static OSystem *instance();
 
+protected:
+        /** Internal init function, called by instance(). */
+        virtual void init() {}
+
 public:
 
         /** Empty virtual destructor. DO NOT REMOVE! */
@@ -367 +371 @@
         /** @name Events and Time */
         //@{
 
-        typedef int (*TimerProc)(int interval);
-
         /**
          * The types of events backends may generate.
          * @see Event
@@ -454 +456 @@
         /** Delay/sleep for the specified amount of milliseconds. */
         virtual void delay_msecs(uint msecs) = 0;
 
+        typedef void (*TimerProc)(void *refCon);
         /**
-         * Set the timer callback, a function which is periodically invoked by the
-         * backend. This can for example be done via a background thread.
-         * There is at most one active timer; if this method is called while there
-         * is already an active timer, then the new timer callback should replace
-         * the previous one. In particular, passing a callback pointer value of 0
-         * is legal and can be used to clear the current timer callback.
-         * @see Common::Timer
-         * @note The implementation of this method must be 'atomic' in the sense
-         *       that when the method returns, the previously set callback must
-         *       not be in use anymore (in particular, if timers are implemented
-         *       via threads, then it must be ensured that the timer thread is
-         *       not using the old callback function anymore).
+         * Install a new timer callback. It will from now be called every interval microseconds.
+         * The timer may be invoked from a separate thread. Hence any timer code should be
+         * written following the same safety guidelines as any other threaded code.
          *
-         * @param callback      pointer to the callback. May be 0 to reset the timer
-         * @param interval      the interval (in milliseconds) between invocations
-         *                  of the callback
+         * @note Although the interval is specified in microseconds, the actual timer resolution
+         *       may be lower. In particular, with the SDL backend the timer resolution is 10ms.
+         * @param proc          the callback
+         * @param interval      the interval in which the timer shall be invoked (in microseconds)
+         * @param refCon        an arbitrary void pointer; will be passed to the timer callback
+         * @return      true if the timer was installed successfully, false otherwise
          */
-        virtual void setTimerCallback(TimerProc callback, int interval) = 0;
+        virtual bool installTimerProc(TimerProc proc, int32 interval, void *refCon) = 0;
+
+        /**
+         * Remove the given timer callback. It will not be invoked anymore.
+         */
+        virtual void removeTimerProc(TimerProc proc) = 0;
 
         //@}
 
@@ -627 +629 @@
         //@}
 };
 
+
+/**
+ * This class provides a default implementation of the new OSystem timer API
+ * by emulating it using the old timer API. This makes it easy to get old
+ * backends to work with the new code, and also makes it easier to write new
+ * backends from scratch.
+ */
+class OSystemWithDefaultTimerCode : public OSystem {
+public:
+        OSystemWithDefaultTimerCode();
+
+        bool installTimerProc(TimerProc proc, int32 interval, void *refCon);
+        void removeTimerProc(TimerProc proc);
+
+        typedef int (*TimerCallback)(int interval);
+
+        /**
+         * Set the timer callback, a function which is periodically invoked by the
+         * backend. This can for example be done via a background thread.
+         * There is at most one active timer; if this method is called while there
+         * is already an active timer, then the new timer callback should replace
+         * the previous one. In particular, passing a callback pointer value of 0
+         * is legal and can be used to clear the current timer callback.
+         * @see Common::Timer
+         * @note The implementation of this method must be 'atomic' in the sense
+         *       that when the method returns, the previously set callback must
+         *       not be in use anymore (in particular, if timers are implemented
+         *       via threads, then it must be ensured that the timer thread is
+         *       not using the old callback function anymore).
+         *
+         * @param callback      pointer to the callback. May be 0 to reset the timer
+         * @param interval      the interval (in milliseconds) between invocations
+         *                  of the callback
+         */
+        virtual void setTimerCallback(TimerCallback callback, int interval) = 0;
+
+protected:
+        void init();
+
+        // TODO: The deinit() methods currently is never called. However, that
+        // should hopefully never be a problem, since the quit() method of classes
+        // derived from this class should remove any timer callbacks anyway...
+        void deinit();
+
+private:
+        #define MAX_TIMERS 2
+
+        MutexRef _timerMutex;
+        void *_timerCallback;
+        int32 _timerThisTime;
+        int32 _timerLastTime;
+
+        struct TimerSlots {
+                TimerProc procedure;
+                int32 interval;
+                int32 counter;
+                void *refCon;
+        } _timerSlots[MAX_TIMERS];
+
+        static int timerCallback(int t);
+        int timerMain(int t);
+};
+
 /** The global OSystem instance. Inited in main(). */
 #define g_system        (OSystem::instance())
 

queen/queen.cpp

@@ -28 +28 @@
 
 #include "common/config-manager.h"
 #include "common/file.h"
-#include "common/timer.h"
 
 #include "queen/queen.h"
 #include "queen/bankman.h"

saga/render.cpp

@@ -38 +38 @@
 #include "saga/objectmap.h"
 
 #include "saga/render.h"
-#include <common/timer.h>
 
 namespace Saga {
 
@@ -62 +61 @@
         GAME_GetDisplayInfo(&disp_info);
 
         // Initialize FPS timer callback
-        g_timer->installTimerProc(&fpsTimerCallback, 1000000, this);
+        system->installTimerProc(&fpsTimerCallback, 1000000, this);
 
         // Create background buffer 
         _bg_buf_w = disp_info.logical_w;

scumm/midiparser_ro.cpp

@@ -20 +20 @@
  */
 
 #include "stdafx.h"
+
+#include "common/util.h"
+
 #include "sound/midiparser.h"
 #include "sound/mididrv.h"
-#include "common/util.h"
 
 
 namespace Scumm {

scumm/sound.cpp

@@ -29 +29 @@
 #include "scumm/sound.h"
 
 #include "common/config-manager.h"
-#include "common/timer.h"
 #include "common/util.h"
 
 #include "sound/audiocd.h"
@@ -1122 +1121 @@
         else 
                 timer_interval = 101;
 
-        _vm->_timer->removeTimerProc(&cd_timer_handler);
-        _vm->_timer->installTimerProc(&cd_timer_handler, 1000 * timer_interval, _vm);
+        _vm->_system->removeTimerProc(&cd_timer_handler);
+        _vm->_system->installTimerProc(&cd_timer_handler, 1000 * timer_interval, _vm);
 }
 
 void Sound::stopCDTimer() {
-        _vm->_timer->removeTimerProc(&cd_timer_handler);
+        _vm->_system->removeTimerProc(&cd_timer_handler);
 }
 
 void Sound::playCDTrack(int track, int numLoops, int startFrame, int duration) {

scumm/imuse_digi/dimuse.cpp

@@ -19 +19 @@
  */
 
 #include "stdafx.h"
-#include "common/timer.h"
 
 #include "scumm/actor.h"
 #include "scumm/scumm.h"
@@ -55 +54 @@
                 _track[l] = new Track;
                 _track[l]->used = false;
         }
-        _vm->_timer->installTimerProc(timer_handler, 1000000 / _callbackFps, this);
+        _vm->_system->installTimerProc(timer_handler, 1000000 / _callbackFps, this);
 }
 
 IMuseDigital::~IMuseDigital() {
         stopAllSounds();
-        _vm->_timer->removeTimerProc(timer_handler);
+        _vm->_system->removeTimerProc(timer_handler);
         for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
                 delete _track[l];
         }

scumm/imuse_digi/dimuse_script.cpp

@@ -19 +19 @@
  */
 
 #include "stdafx.h"
-#include "common/timer.h"
 
 #include "scumm/actor.h"
 #include "scumm/scumm.h"

scumm/imuse_digi/dimuse_track.cpp

@@ -19 +19 @@
  */
 
 #include "stdafx.h"
-#include "common/timer.h"
 
 #include "scumm/actor.h"
 #include "scumm/scumm.h"

scumm/smush/smush_player.cpp

@@ -26 +26 @@
 #include "common/config-manager.h"
 #include "common/file.h"
 #include "common/util.h"
-#include "common/timer.h"
 
 #include "scumm/bomp.h"
 #include "scumm/imuse_digi/dimuse.h"
@@ -255 +254 @@
         _vm->setDirtyColors(0, 255);
         _dst = _vm->virtscr[0].getPixels(0, 0);
         _smixer = new SmushMixer(_vm->_mixer);
-        g_timer->installTimerProc(&timerCallback, _speed, this);
+        _vm->_system->installTimerProc(&timerCallback, _speed, this);
 }
 
 void SmushPlayer::release() {
-        _vm->_timer->removeTimerProc(&timerCallback);
+        _vm->_system->removeTimerProc(&timerCallback);
 
         _vm->_smushVideoShouldFinish = true;
 

sky/sky.cpp

@@ -28 +28 @@
 
 #include "common/config-manager.h"
 #include "common/file.h"
-#include "common/timer.h"
 
 #include "sky/compact.h"
 #include "sky/control.h"
@@ -296 +295 @@
         _skyMouse->useLogicInstance(_skyLogic);
         
         // initialize timer *after* _skyScreen has been initialized.
-        _timer->installTimerProc(&timerHandler, 1000000 / 50, this); //call 50 times per second
+        _system->installTimerProc(&timerHandler, 1000000 / 50, this); //call 50 times per second
 
         _skyControl = new Control(_saveFileMan, _skyScreen, _skyDisk, _skyMouse, _skyText, _skyMusic, _skyLogic, _skySound, _system, getSavePath());
         _skyLogic->useControlInstance(_skyControl);

sound/mididrv.h

@@ -24 +24 @@
 #define SOUND_MIDIDRV_H
 
 #include "common/scummsys.h"
-#include "common/timer.h"
+#include "common/system.h"
 
 class MidiChannel;
 class SoundMixer;
@@ -125 +125 @@
         virtual void metaEvent (byte type, byte*data, uint16 length) { }
 
         // Timing functions - MidiDriver now operates timers
-        virtual void setTimerCallback (void *timer_param, Timer::TimerProc timer_proc) = 0;
+        virtual void setTimerCallback (void *timer_param, OSystem::TimerProc timer_proc) = 0;
         virtual uint32 getBaseTempo (void) = 0;
 
         // Channel allocation functions

sound/mpu401.cpp

@@ -19 +19 @@
  */
 
 #include "stdafx.h"
-#include "mpu401.h"
-#include "common/timer.h"
+
+#include "common/system.h"
 #include "common/util.h"        // for ARRAYSIZE
 
+#include "sound/mpu401.h"
+
 void MidiChannel_MPU401::init(MidiDriver_MPU401 *owner, byte channel) {
         _owner = owner;
         _channel = channel;
@@ -93 +95 @@
 
 void MidiDriver_MPU401::close() {
         if (_timer_proc)
-                g_timer->removeTimerProc(_timer_proc);
+                g_system->removeTimerProc(_timer_proc);
         _timer_proc = 0;
         for (int i = 0; i < 16; ++i)
                 send (0x7B << 8 | 0xB0 | i);
@@ -125 +127 @@
         return NULL;
 }
 
-void MidiDriver_MPU401::setTimerCallback(void *timer_param, Timer::TimerProc timer_proc) {
+void MidiDriver_MPU401::setTimerCallback(void *timer_param, OSystem::TimerProc timer_proc) {
         if (!_timer_proc || !timer_proc) {
                 if (_timer_proc)
-                        g_timer->removeTimerProc(_timer_proc);
+                        g_system->removeTimerProc(_timer_proc);
                 _timer_proc = timer_proc;
                 if (timer_proc)
-                        g_timer->installTimerProc(timer_proc, 10000, timer_param);
+                        g_system->installTimerProc(timer_proc, 10000, timer_param);
         }
 }

sound/mpu401.h

@@ -23 +23 @@
 #define SOUND_MPU401_H
 
 #include "stdafx.h"
+
 #include "common/system.h"
-#include "mididrv.h"
+
+#include "sound/mididrv.h"
 
 ////////////////////////////////////////
 //
@@ -71 +73 @@
 class MidiDriver_MPU401 : public MidiDriver {
 private:
         MidiChannel_MPU401 _midi_channels [16];
-        Timer::TimerProc _timer_proc;
+        OSystem::TimerProc _timer_proc;
         uint16 _channel_mask;
 
 public:
         MidiDriver_MPU401();
 
         virtual void close();
-        void setTimerCallback(void *timer_param, Timer::TimerProc timer_proc);
+        void setTimerCallback(void *timer_param, OSystem::TimerProc timer_proc);
         uint32 getBaseTempo(void) { return 10000; }
         uint32 property(int prop, uint32 param);
 

sword1/sword1.cpp

@@ -27 +27 @@
 #include "base/plugins.h"
 #include "common/config-manager.h"
 #include "common/file.h"
-#include "common/timer.h"
 
 #include "memman.h"
 #include "resman.h"