multimedia/time.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * MMSYTEM time functions
   5  *
   6  * Copyright 1993 Martin Ayotte
   7  */
   8
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <time.h>
  12 #include "windows.h"
  13 #include "win.h"
  14 #include "ldt.h"
  15 #include "module.h"
  16 #include "callback.h"
  17 #include "user.h"
  18 #include "driver.h"
  19 #include "mmsystem.h"
  20 #include "debug.h"
  21 #include "xmalloc.h"
  22 #include "options.h"
  23
  24 #define USE_FAKE_MM_TIMERS
  25
  26 static MMTIME16 mmSysTimeMS;
  27 static MMTIME16 mmSysTimeSMPTE;
  28
  29 typedef struct tagTIMERENTRY {
  30     UINT32                      wDelay;
  31     UINT32                      wResol;
  32     FARPROC16                   lpFunc;
  33     HINSTANCE32                 hInstance;
  34     DWORD                       dwUser;
  35     UINT32                      wFlags;
  36     UINT32                      wTimerID;
  37     UINT32                      wCurTime;
  38     UINT32                      isWin32;
  39     struct tagTIMERENTRY*       Next;
  40 } TIMERENTRY, *LPTIMERENTRY;
  41
  42 static LPTIMERENTRY lpTimerList = NULL;
  43
  44 #ifdef USE_FAKE_MM_TIMERS
  45 static DWORD dwLastCBTick = 0;
  46 static BOOL32 bUseFakeTimers = FALSE;
  47 static WORD wInCallBackLoop = 0;
  48 #endif
  49
  50 /*
  51  * FIXME
  52  * We're using "1" as the mininum resolution to the timer,
  53  * as Windows 95 does, according to the docs. Maybe it should
  54  * depend on the computers resources!
  55  */
  56 #define MMSYSTIME_MININTERVAL (1)
  57 #define MMSYSTIME_MAXINTERVAL (65535)
  58
  59 static  void    TIME_TriggerCallBack(LPTIMERENTRY lpTimer, DWORD dwCurrent)
  60 {
  61     lpTimer->wCurTime = lpTimer->wDelay;
  62
  63     if (lpTimer->lpFunc != (FARPROC16) NULL) {
  64         TRACE(mmtime, "before CallBack16 (%lu)!\n", dwCurrent);
  65         TRACE(mmtime, "lpFunc=%p wTimerID=%04X dwUser=%08lX !\n",
  66               lpTimer->lpFunc, lpTimer->wTimerID, lpTimer->dwUser);
  67         TRACE(mmtime, "hInstance=%04X !\n", lpTimer->hInstance);
  68
  69
  70         /* - TimeProc callback that is called here is something strange, under Windows 3.1x it is called
  71          *              during interrupt time,  is allowed to execute very limited number of API calls (like
  72          *              PostMessage), and must reside in DLL (therefore uses stack of active application). So I
  73          *       guess current implementation via SetTimer has to be improved upon.
  74          */
  75         switch (lpTimer->wFlags & 0x30) {
  76         case TIME_CALLBACK_FUNCTION:
  77                 if (lpTimer->isWin32)
  78                     lpTimer->lpFunc(lpTimer->wTimerID,0,lpTimer->dwUser,0,0);
  79                 else
  80                     Callbacks->CallTimeFuncProc(lpTimer->lpFunc,
  81                                                 lpTimer->wTimerID,0,
  82                                                 lpTimer->dwUser,0,0);
  83                 break;
  84         case TIME_CALLBACK_EVENT_SET:
  85                 SetEvent((HANDLE32)lpTimer->lpFunc);
  86                 break;
  87         case TIME_CALLBACK_EVENT_PULSE:
  88                 PulseEvent((HANDLE32)lpTimer->lpFunc);
  89                 break;
  90         default:
  91                 FIXME(mmtime,"Unknown callback type 0x%04x for mmtime callback (%p),ignored.\n",lpTimer->wFlags,lpTimer->lpFunc);
  92                 break;
  93         }
  94         TRACE(mmtime, "after CallBack16 !\n");
  95         fflush(stdout);
  96     }
  97     if (lpTimer->wFlags & TIME_ONESHOT)
  98         timeKillEvent32(lpTimer->wTimerID);
  99 }
 100
 101 /**************************************************************************
 102  *           TIME_MMSysTimeCallback
 103  */
 104 static VOID WINAPI TIME_MMSysTimeCallback( HWND32 hwnd, UINT32 msg,
 105                                     UINT32 id, DWORD dwTime )
 106 {
 107     LPTIMERENTRY lpTimer;
 108
 109     mmSysTimeMS.u.ms += MMSYSTIME_MININTERVAL;
 110     mmSysTimeSMPTE.u.smpte.frame++;
 111
 112 #ifdef USE_FAKE_MM_TIMERS
 113     if (bUseFakeTimers)
 114         dwLastCBTick = GetTickCount();
 115
 116     if (!wInCallBackLoop++)
 117 #endif
 118         for (lpTimer = lpTimerList; lpTimer != NULL; lpTimer = lpTimer->Next) {
 119             if (lpTimer->wCurTime < MMSYSTIME_MININTERVAL) {
 120                 TIME_TriggerCallBack(lpTimer, dwTime);
 121             } else {
 122                 lpTimer->wCurTime -= MMSYSTIME_MININTERVAL;
 123             }
 124         }
 125 #ifdef USE_FAKE_MM_TIMERS
 126     wInCallBackLoop--;
 127 #endif
 128 }
 129
 130 /**************************************************************************
 131  *                              StartMMTime                     [internal]
 132  */
 133 static void StartMMTime()
 134 {
 135     static BOOL32       mmTimeStarted = FALSE;
 136
 137     if (!mmTimeStarted) {
 138         mmTimeStarted = TRUE;
 139         mmSysTimeMS.wType = TIME_MS;
 140         mmSysTimeMS.u.ms = 0;
 141         mmSysTimeSMPTE.wType = TIME_SMPTE;
 142         mmSysTimeSMPTE.u.smpte.hour = 0;
 143         mmSysTimeSMPTE.u.smpte.min = 0;
 144         mmSysTimeSMPTE.u.smpte.sec = 0;
 145         mmSysTimeSMPTE.u.smpte.frame = 0;
 146         mmSysTimeSMPTE.u.smpte.fps = 0;
 147         mmSysTimeSMPTE.u.smpte.dummy = 0;
 148         SetTimer32( 0, 0, MMSYSTIME_MININTERVAL, TIME_MMSysTimeCallback );
 149 #ifdef USE_FAKE_MM_TIMERS
 150         bUseFakeTimers = PROFILE_GetWineIniBool("options", "MMFakeTimers", TRUE);
 151         TRACE(mmtime, "FakeTimer=%c\n", bUseFakeTimers ? 'Y' : 'N');
 152         if (bUseFakeTimers)
 153             dwLastCBTick = GetTickCount();
 154 #endif
 155     }
 156 }
 157
 158 /**************************************************************************
 159  *                              timeGetSystemTime       [WINMM.140]
 160  */
 161 MMRESULT32 WINAPI timeGetSystemTime32(LPMMTIME32 lpTime, UINT32 wSize)
 162 {
 163     TRACE(mmsys, "(%p, %u);\n", lpTime, wSize);
 164     StartMMTime();
 165     lpTime->wType = TIME_MS;
 166     lpTime->u.ms = mmSysTimeMS.u.ms;
 167     return 0;
 168 }
 169
 170 /**************************************************************************
 171  *                              timeGetSystemTime       [MMSYSTEM.601]
 172  */
 173 MMRESULT16 WINAPI timeGetSystemTime16(LPMMTIME16 lpTime, UINT16 wSize)
 174 {
 175     TRACE(mmsys, "(%p, %u);\n", lpTime, wSize);
 176     StartMMTime();
 177     lpTime->wType = TIME_MS;
 178     lpTime->u.ms = mmSysTimeMS.u.ms;
 179     return 0;
 180 }
 181
 182 static  WORD    timeSetEventInternal(UINT32 wDelay,UINT32 wResol,
 183                                      FARPROC16 lpFunc,DWORD dwUser,
 184                                      UINT32 wFlags, UINT16 isWin32)
 185 {
 186     WORD                wNewID = 0;
 187     LPTIMERENTRY        lpNewTimer;
 188     LPTIMERENTRY        lpTimer = lpTimerList;
 189
 190     TRACE(mmtime, "(%u, %u, %p, %08lX, %04X);\n",
 191           wDelay, wResol, lpFunc, dwUser, wFlags);
 192     StartMMTime();
 193     lpNewTimer = (LPTIMERENTRY)xmalloc(sizeof(TIMERENTRY));
 194     if (lpNewTimer == NULL)
 195         return 0;
 196     while (lpTimer != NULL) {
 197         wNewID = MAX(wNewID, lpTimer->wTimerID);
 198         lpTimer = lpTimer->Next;
 199     }
 200
 201     lpNewTimer->Next = lpTimerList;
 202     lpTimerList = lpNewTimer;
 203     lpNewTimer->wTimerID = wNewID + 1;
 204     lpNewTimer->wCurTime = wDelay;
 205     lpNewTimer->wDelay = wDelay;
 206     lpNewTimer->wResol = wResol;
 207     lpNewTimer->lpFunc = lpFunc;
 208     lpNewTimer->isWin32 = isWin32;
 209     lpNewTimer->hInstance = GetTaskDS();
 210     TRACE(mmtime, "hInstance=%04X !\n", lpNewTimer->hInstance);
 211     TRACE(mmtime, "lpFunc=%p !\n", isWin32 ? lpFunc : PTR_SEG_TO_LIN(lpFunc));
 212     lpNewTimer->dwUser = dwUser;
 213     lpNewTimer->wFlags = wFlags;
 214     return lpNewTimer->wTimerID;
 215 }
 216
 217 /**************************************************************************
 218  *                              timeSetEvent            [MMSYSTEM.602]
 219  */
 220 MMRESULT32 WINAPI timeSetEvent32(UINT32 wDelay,UINT32 wResol,
 221                                  LPTIMECALLBACK32 lpFunc,DWORD dwUser,
 222                                  UINT32 wFlags)
 223 {
 224     return timeSetEventInternal(wDelay, wResol, (FARPROC16)lpFunc,
 225                                 dwUser, wFlags, 1);
 226 }
 227
 228 /**************************************************************************
 229  *                              timeSetEvent            [MMSYSTEM.602]
 230  */
 231 MMRESULT16 WINAPI timeSetEvent16(UINT16 wDelay, UINT16 wResol,
 232                                  LPTIMECALLBACK16 lpFunc,DWORD dwUser,
 233                                  UINT16 wFlags)
 234 {
 235     return timeSetEventInternal(wDelay, wResol, (FARPROC16)lpFunc,
 236                                 dwUser, wFlags, 0);
 237 }
 238
 239 /**************************************************************************
 240  *                              timeKillEvent           [WINMM.142]
 241  */
 242 MMRESULT32 WINAPI timeKillEvent32(UINT32 wID)
 243 {
 244     LPTIMERENTRY*       lpTimer;
 245
 246     for (lpTimer = &lpTimerList; *lpTimer; lpTimer = &((*lpTimer)->Next)) {
 247         if (wID == (*lpTimer)->wTimerID) {
 248             LPTIMERENTRY xlptimer = (*lpTimer)->Next;
 249
 250             free(*lpTimer);
 251             *lpTimer = xlptimer;
 252             return TRUE;
 253         }
 254     }
 255     return 0;
 256 }
 257
 258 /**************************************************************************
 259  *                              timeKillEvent           [MMSYSTEM.603]
 260  */
 261 MMRESULT16 WINAPI timeKillEvent16(UINT16 wID)
 262 {
 263     return timeKillEvent32(wID);
 264 }
 265
 266 /**************************************************************************
 267  *                              timeGetDevCaps          [WINMM.139]
 268  */
 269 MMRESULT32 WINAPI timeGetDevCaps32(LPTIMECAPS32 lpCaps,UINT32 wSize)
 270 {
 271     TRACE(mmtime, "(%p, %u) !\n", lpCaps, wSize);
 272     StartMMTime();
 273     lpCaps->wPeriodMin = MMSYSTIME_MININTERVAL;
 274     lpCaps->wPeriodMax = MMSYSTIME_MAXINTERVAL;
 275     return 0;
 276 }
 277
 278 /**************************************************************************
 279  *                              timeGetDevCaps          [MMSYSTEM.604]
 280  */
 281 MMRESULT16 WINAPI timeGetDevCaps16(LPTIMECAPS16 lpCaps, UINT16 wSize)
 282 {
 283     TRACE(mmtime, "(%p, %u) !\n", lpCaps, wSize);
 284     StartMMTime();
 285     lpCaps->wPeriodMin = MMSYSTIME_MININTERVAL;
 286     lpCaps->wPeriodMax = MMSYSTIME_MAXINTERVAL;
 287     return 0;
 288 }
 289
 290 /**************************************************************************
 291  *                              timeBeginPeriod         [WINMM.137]
 292  */
 293 MMRESULT32 WINAPI timeBeginPeriod32(UINT32 wPeriod)
 294 {
 295     TRACE(mmtime, "(%u) !\n", wPeriod);
 296     StartMMTime();
 297     if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
 298         return TIMERR_NOCANDO;
 299     return 0;
 300 }
 301 /**************************************************************************
 302  *                              timeBeginPeriod         [MMSYSTEM.605]
 303  */
 304 MMRESULT16 WINAPI timeBeginPeriod16(UINT16 wPeriod)
 305 {
 306     TRACE(mmtime, "(%u) !\n", wPeriod);
 307     StartMMTime();
 308     if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
 309         return TIMERR_NOCANDO;
 310     return 0;
 311 }
 312
 313 /**************************************************************************
 314  *                              timeEndPeriod           [WINMM.138]
 315  */
 316 MMRESULT32 WINAPI timeEndPeriod32(UINT32 wPeriod)
 317 {
 318     TRACE(mmtime, "(%u) !\n", wPeriod);
 319     StartMMTime();
 320     if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
 321         return TIMERR_NOCANDO;
 322     return 0;
 323 }
 324
 325 /**************************************************************************
 326  *                              timeEndPeriod           [MMSYSTEM.606]
 327  */
 328 MMRESULT16 WINAPI timeEndPeriod16(UINT16 wPeriod)
 329 {
 330     TRACE(mmtime, "(%u) !\n", wPeriod);
 331     if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
 332         return TIMERR_NOCANDO;
 333     return 0;
 334 }
 335
 336 /**************************************************************************
 337  *                              timeGetTime    [MMSYSTEM.607][WINMM.141]
 338  */
 339 DWORD WINAPI timeGetTime()
 340 {
 341     DWORD       dwNewTick = GetTickCount();
 342
 343     StartMMTime();
 344 #ifdef USE_FAKE_MM_TIMERS
 345     if (bUseFakeTimers) {
 346         if (wInCallBackLoop++) {
 347             DWORD               dwDelta;
 348
 349
 350             if (dwNewTick < dwLastCBTick) {
 351                 ERR(mmtime, "dwNewTick(%lu) < dwLastCBTick(%lu)\n", dwNewTick, dwLastCBTick);
 352             }
 353             dwDelta = dwNewTick - dwLastCBTick;
 354             if (dwDelta > MMSYSTIME_MININTERVAL) {
 355                 LPTIMERENTRY lpTimer;
 356
 357                 mmSysTimeMS.u.ms += dwDelta; /* FIXME: faked timer */
 358                 dwLastCBTick = dwNewTick;
 359                 for (lpTimer = lpTimerList; lpTimer != NULL; lpTimer = lpTimer->Next) {
 360                     if (lpTimer->wCurTime < dwDelta) {
 361                         TIME_TriggerCallBack(lpTimer, dwNewTick);
 362                     } else {
 363                         lpTimer->wCurTime -= dwDelta;
 364                     }
 365                 }
 366                 dwNewTick = mmSysTimeMS.u.ms;
 367             }
 368         }
 369         wInCallBackLoop--;
 370     }
 371 #endif
 372     return dwNewTick;
 373 }