git.oblomov.eu Git - wine/blob - multimedia/mcianim.c

   1 /*
   2  * Sample MCI ANIMATION Wine Driver for Linux
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  *
   6 static char Copyright[] = "Copyright  Martin Ayotte, 1994";
   7 */
   8 #ifndef WINELIB
   9 #define BUILTIN_MMSYSTEM
  10 #endif
  11
  12 #ifdef BUILTIN_MMSYSTEM
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <unistd.h>
  17 #include <string.h>
  18 #include <fcntl.h>
  19 #include <sys/ioctl.h>
  20 #include "windows.h"
  21 #include "user.h"
  22 #include "driver.h"
  23 #include "mmsystem.h"
  24 #include "stddebug.h"
  25 /* #define DEBUG_MCIANIM */
  26 #define DEBUG_MCIANIM
  27 #include "debug.h"
  28
  29 #define MAX_ANIMDRV             2
  30
  31 #define ANIMFRAMES_PERSEC       30
  32 #define ANIMFRAMES_PERMIN       1800
  33 #define SECONDS_PERMIN          60
  34
  35 #ifdef linux
  36 typedef struct {
  37     int     nUseCount;          /* Incremented for each shared open */
  38     BOOL    fShareable;         /* TRUE if first open was shareable */
  39     WORD    wNotifyDeviceID;    /* MCI device ID with a pending notification */
  40     HANDLE  hCallback;          /* Callback handle for pending notification */
  41         MCI_OPEN_PARMS openParms;
  42         DWORD   dwTimeFormat;
  43         int             mode;
  44         UINT    nCurTrack;
  45         DWORD   dwCurFrame;
  46         UINT    nTracks;
  47         DWORD   dwTotalLen;
  48         LPDWORD lpdwTrackLen;
  49         LPDWORD lpdwTrackPos;
  50         } LINUX_ANIM;
  51
  52 static LINUX_ANIM       AnimDev[MAX_ANIMDRV];
  53 #endif
  54
  55
  56 DWORD ANIM_CalcTime(UINT wDevID, DWORD dwFormatType, DWORD dwFrame);
  57 DWORD ANIM_CalcFrame(UINT wDevID, DWORD dwFormatType, DWORD dwTime);
  58
  59
  60 /*-----------------------------------------------------------------------*/
  61
  62 /**************************************************************************
  63 *                               ANIM_mciOpen                    [internal]
  64 */
  65 DWORD ANIM_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpParms)
  66 {
  67 #ifdef linux
  68         LPSTR           lpstrElementName;
  69         char            str[128];
  70         dprintf_mcianim(stddeb,"ANIM_mciOpen(%04X, %08lX, %p);\n",
  71                                         wDevID, dwFlags, lpParms);
  72         if (lpParms == NULL) return MCIERR_INTERNAL;
  73         if (AnimDev[wDevID].nUseCount > 0) {
  74                 /* The driver already open on this channel */
  75                 /* If the driver was opened shareable before and this open specifies */
  76                 /* shareable then increment the use count */
  77                 if (AnimDev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
  78                         ++AnimDev[wDevID].nUseCount;
  79                 else
  80                         return MCIERR_MUST_USE_SHAREABLE;
  81                 }
  82         else {
  83                 AnimDev[wDevID].nUseCount = 1;
  84                 AnimDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE;
  85                 }
  86         dprintf_mcianim(stddeb,"ANIM_mciOpen // wDevID=%04X\n", wDevID);
  87         lpParms->wDeviceID = wDevID;
  88         dprintf_mcianim(stddeb,"ANIM_mciOpen // lpParms->wDevID=%04X\n", lpParms->wDeviceID);
  89     if (dwFlags & MCI_OPEN_ELEMENT) {
  90                 lpstrElementName = (LPSTR)PTR_SEG_TO_LIN(lpParms->lpstrElementName);
  91                 dprintf_mcianim(stddeb,"ANIM_mciOpen // MCI_OPEN_ELEMENT '%s' !\n",
  92                                                 lpstrElementName);
  93                 if (strlen(lpstrElementName) > 0) {
  94                         strcpy(str, lpstrElementName);
  95                         AnsiUpper(str);
  96                         }
  97                 }
  98         memcpy(&AnimDev[wDevID].openParms, lpParms, sizeof(MCI_OPEN_PARMS));
  99         AnimDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID;
 100         AnimDev[wDevID].mode = 0;
 101         AnimDev[wDevID].dwTimeFormat = MCI_FORMAT_TMSF;
 102         AnimDev[wDevID].nCurTrack = 0;
 103         AnimDev[wDevID].nTracks = 0;
 104         AnimDev[wDevID].dwTotalLen = 0;
 105         AnimDev[wDevID].lpdwTrackLen = NULL;
 106         AnimDev[wDevID].lpdwTrackPos = NULL;
 107         if (dwFlags & MCI_NOTIFY) {
 108                 dprintf_mcianim(stddeb,
 109                         "ANIM_mciOpen // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
 110                         lpParms->dwCallback);
 111                 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 112                         AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 113                 }
 114         return 0;
 115 #else
 116         return MCIERR_HARDWARE;
 117 #endif
 118 }
 119
 120 /**************************************************************************
 121 *                               ANIM_mciClose           [internal]
 122 */
 123 DWORD ANIM_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
 124 {
 125 #ifdef linux
 126         dprintf_mcianim(stddeb,"ANIM_mciClose(%u, %08lX, %p);\n",
 127                                 wDevID, dwParam, lpParms);
 128         if (AnimDev[wDevID].lpdwTrackLen != NULL) free(AnimDev[wDevID].lpdwTrackLen);
 129         if (AnimDev[wDevID].lpdwTrackPos != NULL) free(AnimDev[wDevID].lpdwTrackPos);
 130 #endif
 131         return 0;
 132 }
 133
 134 /**************************************************************************
 135 *                               ANIM_mciGetDevCaps      [internal]
 136 */
 137 DWORD ANIM_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
 138                                                 LPMCI_GETDEVCAPS_PARMS lpParms)
 139 {
 140 #ifdef linux
 141         dprintf_mcianim(stddeb,"ANIM_mciGetDevCaps(%u, %08lX, %p);\n",
 142                                 wDevID, dwFlags, lpParms);
 143         if (lpParms == NULL) return MCIERR_INTERNAL;
 144         if (dwFlags & MCI_GETDEVCAPS_ITEM) {
 145                 dprintf_mcianim(stddeb,
 146                 "ANIM_mciGetDevCaps // MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n",
 147                                 lpParms->dwItem);
 148                 switch(lpParms->dwItem) {
 149                         case MCI_GETDEVCAPS_CAN_RECORD:
 150                                 lpParms->dwReturn = FALSE;
 151                                 break;
 152                         case MCI_GETDEVCAPS_HAS_AUDIO:
 153                                 lpParms->dwReturn = FALSE;
 154                                 break;
 155                         case MCI_GETDEVCAPS_HAS_VIDEO:
 156                                 lpParms->dwReturn = FALSE;
 157                                 break;
 158                         case MCI_GETDEVCAPS_DEVICE_TYPE:
 159                                 lpParms->dwReturn = MCI_DEVTYPE_ANIMATION;
 160                                 break;
 161                         case MCI_GETDEVCAPS_USES_FILES:
 162                                 lpParms->dwReturn = TRUE;
 163                                 break;
 164                         case MCI_GETDEVCAPS_COMPOUND_DEVICE:
 165                                 lpParms->dwReturn = FALSE;
 166                                 break;
 167                         case MCI_GETDEVCAPS_CAN_EJECT:
 168                                 lpParms->dwReturn = TRUE;
 169                                 break;
 170                         case MCI_GETDEVCAPS_CAN_PLAY:
 171                                 lpParms->dwReturn = FALSE;
 172                                 break;
 173                         case MCI_GETDEVCAPS_CAN_SAVE:
 174                                 lpParms->dwReturn = FALSE;
 175                                 break;
 176                         default:
 177                                 return MCIERR_UNRECOGNIZED_COMMAND;
 178                         }
 179                 }
 180         dprintf_mcianim(stddeb,
 181                 "ANIM_mciGetDevCaps // lpParms->dwReturn=%08lX;\n",
 182                 lpParms->dwReturn);
 183         return 0;
 184 #else
 185         return MCIERR_INTERNAL;
 186 #endif
 187 }
 188
 189 /**************************************************************************
 190 *                               ANIM_mciInfo                    [internal]
 191 */
 192 DWORD ANIM_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms)
 193 {
 194 #ifdef linux
 195         dprintf_mcianim(stddeb,"ANIM_mciInfo(%u, %08lX, %p);\n",
 196                 wDevID, dwFlags, lpParms);
 197         if (lpParms == NULL) return MCIERR_INTERNAL;
 198         lpParms->lpstrReturn = NULL;
 199         switch(dwFlags) {
 200                 case MCI_INFO_PRODUCT:
 201                         lpParms->lpstrReturn = "Linux ANIMATION 0.5";
 202                         break;
 203                 case MCI_INFO_FILE:
 204                         lpParms->lpstrReturn =
 205                                 (LPSTR)AnimDev[wDevID].openParms.lpstrElementName;
 206                         break;
 207                 case MCI_ANIM_INFO_TEXT:
 208                         lpParms->lpstrReturn = "Animation Window";
 209                         break;
 210                 default:
 211                         return MCIERR_UNRECOGNIZED_COMMAND;
 212                 }
 213         if (lpParms->lpstrReturn != NULL)
 214                 lpParms->dwRetSize = strlen(lpParms->lpstrReturn);
 215         else
 216                 lpParms->dwRetSize = 0;
 217         return 0;
 218 #else
 219         return MCIERR_INTERNAL;
 220 #endif
 221 }
 222
 223 /**************************************************************************
 224 *                               ANIM_mciStatus          [internal]
 225 */
 226 DWORD ANIM_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
 227 {
 228 #ifdef linux
 229         dprintf_mcianim(stddeb,"ANIM_mciStatus(%u, %08lX, %p);\n",
 230                         wDevID, dwFlags, lpParms);
 231         if (lpParms == NULL) return MCIERR_INTERNAL;
 232         if (dwFlags & MCI_NOTIFY) {
 233                 dprintf_mcianim(stddeb,
 234                         "ANIM_mciStatus // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
 235                         lpParms->dwCallback);
 236                 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 237                         AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 238                 }
 239         if (dwFlags & MCI_STATUS_ITEM) {
 240                 switch(lpParms->dwItem) {
 241                         case MCI_STATUS_CURRENT_TRACK:
 242                                 lpParms->dwReturn = AnimDev[wDevID].nCurTrack;
 243                                 dprintf_mcianim(stddeb,"ANIM_mciStatus // CURRENT_TRACK=%lu!\n", lpParms->dwReturn);
 244                                 return 0;
 245                         case MCI_STATUS_LENGTH:
 246                                 if (dwFlags & MCI_TRACK) {
 247                                         dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_TRACK #%lu LENGTH=??? !\n",
 248                                                                                                                 lpParms->dwTrack);
 249                                         if (lpParms->dwTrack > AnimDev[wDevID].nTracks)
 250                                                 return MCIERR_OUTOFRANGE;
 251                                         lpParms->dwReturn = AnimDev[wDevID].lpdwTrackLen[lpParms->dwTrack];
 252                                         }
 253                                 else
 254                                         lpParms->dwReturn = AnimDev[wDevID].dwTotalLen;
 255                                 lpParms->dwReturn = ANIM_CalcTime(wDevID,
 256                                         AnimDev[wDevID].dwTimeFormat, lpParms->dwReturn);
 257                                 dprintf_mcianim(stddeb,"ANIM_mciStatus // LENGTH=%lu !\n", lpParms->dwReturn);
 258                                 return 0;
 259                         case MCI_STATUS_MODE:
 260                                 lpParms->dwReturn = AnimDev[wDevID].mode;
 261                                 dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_MODE=%08lX !\n",
 262                                                                                                 lpParms->dwReturn);
 263                                 return 0;
 264                         case MCI_STATUS_MEDIA_PRESENT:
 265                                 lpParms->dwReturn = TRUE;
 266                                 dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_MEDIA_PRESENT !\n");
 267                                 return 0;
 268                         case MCI_STATUS_NUMBER_OF_TRACKS:
 269                                 lpParms->dwReturn = 1;
 270                                 dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_NUMBER_OF_TRACKS = %lu !\n",
 271                                                                                         lpParms->dwReturn);
 272                                 if (lpParms->dwReturn == (WORD)-1) return MCIERR_INTERNAL;
 273                                 return 0;
 274                         case MCI_STATUS_POSITION:
 275                                 lpParms->dwReturn = AnimDev[wDevID].dwCurFrame;
 276                                 if (dwFlags & MCI_STATUS_START) {
 277                                         lpParms->dwReturn = 0;
 278                                         dprintf_mcianim(stddeb,"CDAUDIO_mciStatus // get MCI_STATUS_START !\n");
 279                                         }
 280                                 if (dwFlags & MCI_TRACK) {
 281                                         if (lpParms->dwTrack > AnimDev[wDevID].nTracks)
 282                                                 return MCIERR_OUTOFRANGE;
 283                                         lpParms->dwReturn = AnimDev[wDevID].lpdwTrackPos[lpParms->dwTrack - 1];
 284                                         dprintf_mcianim(stddeb,"ANIM_mciStatus // get MCI_TRACK #%lu !\n", lpParms->dwTrack);
 285                                         }
 286                                 lpParms->dwReturn = ANIM_CalcTime(wDevID,
 287                                         AnimDev[wDevID].dwTimeFormat, lpParms->dwReturn);
 288                                         dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_POSITION=%08lX !\n",
 289                                                                                                                 lpParms->dwReturn);
 290                                 return 0;
 291                         case MCI_STATUS_READY:
 292                                 dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_READY !\n");
 293                                 lpParms->dwReturn = TRUE;
 294                                 return 0;
 295                         case MCI_STATUS_TIME_FORMAT:
 296                                 dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_TIME_FORMAT !\n");
 297                                 lpParms->dwReturn = MCI_FORMAT_MILLISECONDS;
 298                                 return 0;
 299                         default:
 300                                 fprintf(stderr,"ANIM_mciStatus // unknown command %08lX !\n", lpParms->dwItem);
 301                                 return MCIERR_UNRECOGNIZED_COMMAND;
 302                         }
 303                 }
 304     fprintf(stderr,"ANIM_mciStatus // not MCI_STATUS_ITEM !\n");
 305         return 0;
 306 #else
 307         return MMSYSERR_NOTENABLED;
 308 #endif
 309 }
 310
 311
 312 /**************************************************************************
 313 *                               ANIM_CalcTime                   [internal]
 314 */
 315 DWORD ANIM_CalcTime(UINT wDevID, DWORD dwFormatType, DWORD dwFrame)
 316 {
 317         DWORD   dwTime = 0;
 318 #ifdef linux
 319         UINT    wTrack;
 320         UINT    wMinutes;
 321         UINT    wSeconds;
 322         UINT    wFrames;
 323         dprintf_mcianim(stddeb,"ANIM_CalcTime(%u, %08lX, %lu);\n",
 324                         wDevID, dwFormatType, dwFrame);
 325 TryAGAIN:
 326         switch (dwFormatType) {
 327                 case MCI_FORMAT_MILLISECONDS:
 328                         dwTime = dwFrame / ANIMFRAMES_PERSEC * 1000;
 329                         dprintf_mcianim(stddeb,
 330                                 "ANIM_CalcTime // MILLISECONDS %lu\n", dwTime);
 331                         break;
 332                 case MCI_FORMAT_MSF:
 333                         wMinutes = dwFrame / ANIMFRAMES_PERMIN;
 334                         wSeconds = (dwFrame - ANIMFRAMES_PERMIN * wMinutes) / ANIMFRAMES_PERSEC;
 335                         wFrames = dwFrame - ANIMFRAMES_PERMIN * wMinutes -
 336                                                                 ANIMFRAMES_PERSEC * wSeconds;
 337                         dwTime = MCI_MAKE_MSF(wMinutes, wSeconds, wFrames);
 338                         dprintf_mcianim(stddeb,"ANIM_CalcTime // MSF %02u:%02u:%02u -> dwTime=%lu\n",
 339                                                                 wMinutes, wSeconds, wFrames, dwTime);
 340                         break;
 341                 case MCI_FORMAT_TMSF:
 342                         for (wTrack = 0; wTrack < AnimDev[wDevID].nTracks; wTrack++) {
 343 /*                              dwTime += AnimDev[wDevID].lpdwTrackLen[wTrack - 1];
 344                                 printf("Adding trk#%u curpos=%u \n", dwTime);
 345                                 if (dwTime >= dwFrame) break; */
 346                                 if (AnimDev[wDevID].lpdwTrackPos[wTrack - 1] >= dwFrame) break;
 347                                 }
 348                         wMinutes = dwFrame / ANIMFRAMES_PERMIN;
 349                         wSeconds = (dwFrame - ANIMFRAMES_PERMIN * wMinutes) / ANIMFRAMES_PERSEC;
 350                         wFrames = dwFrame - ANIMFRAMES_PERMIN * wMinutes -
 351                                                                 ANIMFRAMES_PERSEC * wSeconds;
 352                         dwTime = MCI_MAKE_TMSF(wTrack, wMinutes, wSeconds, wFrames);
 353                         dprintf_mcianim(stddeb,
 354                                 "ANIM_CalcTime // %02u-%02u:%02u:%02u\n",
 355                                 wTrack, wMinutes, wSeconds, wFrames);
 356                         break;
 357                 default:
 358                         /* unknown format ! force TMSF ! ... */
 359                         dwFormatType = MCI_FORMAT_TMSF;
 360                         goto TryAGAIN;
 361                 }
 362 #endif
 363         return dwTime;
 364 }
 365
 366
 367 /**************************************************************************
 368 *                               ANIM_CalcFrame                  [internal]
 369 */
 370 DWORD ANIM_CalcFrame(UINT wDevID, DWORD dwFormatType, DWORD dwTime)
 371 {
 372         DWORD   dwFrame = 0;
 373 #ifdef linux
 374         UINT    wTrack;
 375         dprintf_mcianim(stddeb,"ANIM_CalcFrame(%u, %08lX, %lu);\n",
 376                         wDevID, dwFormatType, dwTime);
 377 TryAGAIN:
 378         switch (dwFormatType) {
 379                 case MCI_FORMAT_MILLISECONDS:
 380                         dwFrame = dwTime * ANIMFRAMES_PERSEC / 1000;
 381                         dprintf_mcianim(stddeb,
 382                                 "ANIM_CalcFrame // MILLISECONDS %lu\n", dwFrame);
 383                         break;
 384                 case MCI_FORMAT_MSF:
 385                         dprintf_mcianim(stddeb,
 386                                 "ANIM_CalcFrame // MSF %02u:%02u:%02u\n",
 387                                 MCI_MSF_MINUTE(dwTime), MCI_MSF_SECOND(dwTime),
 388                                 MCI_MSF_FRAME(dwTime));
 389                         dwFrame += ANIMFRAMES_PERMIN * MCI_MSF_MINUTE(dwTime);
 390                         dwFrame += ANIMFRAMES_PERSEC * MCI_MSF_SECOND(dwTime);
 391                         dwFrame += MCI_MSF_FRAME(dwTime);
 392                         break;
 393                 case MCI_FORMAT_TMSF:
 394                         wTrack = MCI_TMSF_TRACK(dwTime);
 395                         dprintf_mcianim(stddeb,
 396                                 "ANIM_CalcFrame // TMSF %02u-%02u:%02u:%02u\n",
 397                                 MCI_TMSF_TRACK(dwTime), MCI_TMSF_MINUTE(dwTime),
 398                                 MCI_TMSF_SECOND(dwTime), MCI_TMSF_FRAME(dwTime));
 399                         dprintf_mcianim(stddeb,
 400                                 "ANIM_CalcFrame // TMSF trackpos[%u]=%lu\n",
 401                                 wTrack, AnimDev[wDevID].lpdwTrackPos[wTrack - 1]);
 402                         dwFrame = AnimDev[wDevID].lpdwTrackPos[wTrack - 1];
 403                         dwFrame += ANIMFRAMES_PERMIN * MCI_TMSF_MINUTE(dwTime);
 404                         dwFrame += ANIMFRAMES_PERSEC * MCI_TMSF_SECOND(dwTime);
 405                         dwFrame += MCI_TMSF_FRAME(dwTime);
 406                         break;
 407                 default:
 408                         /* unknown format ! force TMSF ! ... */
 409                         dwFormatType = MCI_FORMAT_TMSF;
 410                         goto TryAGAIN;
 411                 }
 412 #endif
 413         return dwFrame;
 414 }
 415
 416
 417
 418 /**************************************************************************
 419 *                               ANIM_mciPlay                    [internal]
 420 */
 421 DWORD ANIM_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
 422 {
 423 #ifdef linux
 424         int     start, end;
 425         dprintf_mcianim(stddeb,"ANIM_mciPlay(%u, %08lX, %p);\n",
 426                 wDevID, dwFlags, lpParms);
 427         if (lpParms == NULL) return MCIERR_INTERNAL;
 428         start = 0;              end = AnimDev[wDevID].dwTotalLen;
 429         AnimDev[wDevID].nCurTrack = 1;
 430         if (dwFlags & MCI_FROM) {
 431                 start = ANIM_CalcFrame(wDevID,
 432                         AnimDev[wDevID].dwTimeFormat, lpParms->dwFrom);
 433         dprintf_mcianim(stddeb,"ANIM_mciPlay // MCI_FROM=%08lX -> %u \n",
 434                                 lpParms->dwFrom, start);
 435                 }
 436         if (dwFlags & MCI_TO) {
 437                 end = ANIM_CalcFrame(wDevID,
 438                         AnimDev[wDevID].dwTimeFormat, lpParms->dwTo);
 439                 dprintf_mcianim(stddeb,
 440                         "ANIM_mciPlay // MCI_TO=%08lX -> %u \n",
 441                         lpParms->dwTo, end);
 442                 }
 443         AnimDev[wDevID].mode = MCI_MODE_PLAY;
 444         if (dwFlags & MCI_NOTIFY) {
 445                 dprintf_mcianim(stddeb,
 446                         "ANIM_mciPlay // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
 447                         lpParms->dwCallback);
 448                 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 449                         AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 450                 }
 451         return 0;
 452 #else
 453         return MCIERR_HARDWARE;
 454 #endif
 455 }
 456
 457 /**************************************************************************
 458 *                               ANIM_mciStop                    [internal]
 459 */
 460 DWORD ANIM_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 461 {
 462 #ifdef linux
 463         dprintf_mcianim(stddeb,"ANIM_mciStop(%u, %08lX, %p);\n",
 464                         wDevID, dwFlags, lpParms);
 465         if (lpParms == NULL) return MCIERR_INTERNAL;
 466         AnimDev[wDevID].mode = MCI_MODE_STOP;
 467         if (dwFlags & MCI_NOTIFY) {
 468                 dprintf_mcianim(stddeb,
 469                         "ANIM_mciStop // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
 470                         lpParms->dwCallback);
 471                 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 472                         AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 473                 }
 474         return 0;
 475 #else
 476         return MCIERR_HARDWARE;
 477 #endif
 478 }
 479
 480 /**************************************************************************
 481 *                               ANIM_mciPause           [internal]
 482 */
 483 DWORD ANIM_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 484 {
 485 #ifdef linux
 486         dprintf_mcianim(stddeb,"ANIM_mciPause(%u, %08lX, %p);\n",
 487                 wDevID, dwFlags, lpParms);
 488         if (lpParms == NULL) return MCIERR_INTERNAL;
 489         AnimDev[wDevID].mode = MCI_MODE_PAUSE;
 490         if (dwFlags & MCI_NOTIFY) {
 491                 dprintf_mcianim(stddeb,
 492                         "ANIM_mciPause // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
 493                         lpParms->dwCallback);
 494                 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 495                         AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 496                 }
 497         return 0;
 498 #else
 499         return MCIERR_HARDWARE;
 500 #endif
 501 }
 502
 503 /**************************************************************************
 504 *                               ANIM_mciResume          [internal]
 505 */
 506 DWORD ANIM_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 507 {
 508 #ifdef linux
 509         dprintf_mcianim(stddeb,"ANIM_mciResume(%u, %08lX, %p);\n",
 510                 wDevID, dwFlags, lpParms);
 511         if (lpParms == NULL) return MCIERR_INTERNAL;
 512         AnimDev[wDevID].mode = MCI_MODE_STOP;
 513         if (dwFlags & MCI_NOTIFY) {
 514                 dprintf_mcianim(stddeb,
 515                         "ANIM_mciResume // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
 516                         lpParms->dwCallback);
 517                 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 518                         AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 519                 }
 520         return 0;
 521 #else
 522         return MCIERR_HARDWARE;
 523 #endif
 524 }
 525
 526 /**************************************************************************
 527 *                               ANIM_mciSeek                    [internal]
 528 */
 529 DWORD ANIM_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
 530 {
 531 #ifdef linux
 532         DWORD   dwRet;
 533         MCI_PLAY_PARMS PlayParms;
 534         dprintf_mcianim(stddeb,"ANIM_mciSeek(%u, %08lX, %p);\n",
 535                 wDevID, dwFlags, lpParms);
 536         if (lpParms == NULL) return MCIERR_INTERNAL;
 537         AnimDev[wDevID].mode = MCI_MODE_SEEK;
 538         switch(dwFlags) {
 539                 case MCI_SEEK_TO_START:
 540                         PlayParms.dwFrom = 0;
 541                         break;
 542                 case MCI_SEEK_TO_END:
 543                         PlayParms.dwFrom = AnimDev[wDevID].dwTotalLen;
 544                         break;
 545                 case MCI_TO:
 546                         PlayParms.dwFrom = lpParms->dwTo;
 547                         break;
 548                 }
 549         dwRet = ANIM_mciPlay(wDevID, MCI_WAIT | MCI_FROM, &PlayParms);
 550         if (dwRet != 0) return dwRet;
 551         dwRet = ANIM_mciStop(wDevID, MCI_WAIT, (LPMCI_GENERIC_PARMS)&PlayParms);
 552         if (dwFlags & MCI_NOTIFY) {
 553                 dprintf_mcianim(stddeb,
 554                         "ANIM_mciSeek // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
 555                         lpParms->dwCallback);
 556                 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 557                         AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 558                 }
 559         return dwRet;
 560 #else
 561         return MCIERR_HARDWARE;
 562 #endif
 563 }
 564
 565
 566 /**************************************************************************
 567 *                               ANIM_mciSet                     [internal]
 568 */
 569 DWORD ANIM_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
 570 {
 571 #ifdef linux
 572         dprintf_mcianim(stddeb,"ANIM_mciSet(%u, %08lX, %p);\n",
 573                 wDevID, dwFlags, lpParms);
 574         if (lpParms == NULL) return MCIERR_INTERNAL;
 575 /*
 576         printf("ANIM_mciSet // dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
 577         printf("ANIM_mciSet // dwAudio=%08lX\n", lpParms->dwAudio);
 578 */
 579         if (dwFlags & MCI_SET_TIME_FORMAT) {
 580                 switch (lpParms->dwTimeFormat) {
 581                         case MCI_FORMAT_MILLISECONDS:
 582                                 dprintf_mcianim(stddeb,
 583                                         "ANIM_mciSet // MCI_FORMAT_MILLISECONDS !\n");
 584                                 break;
 585                         case MCI_FORMAT_MSF:
 586                                 dprintf_mcianim(stddeb,"ANIM_mciSet // MCI_FORMAT_MSF !\n");
 587                                 break;
 588                         case MCI_FORMAT_TMSF:
 589                                 dprintf_mcianim(stddeb,"ANIM_mciSet // MCI_FORMAT_TMSF !\n");
 590                                 break;
 591                         default:
 592                                 fprintf(stderr,"ANIM_mciSet // bad time format !\n");
 593                                 return MCIERR_BAD_TIME_FORMAT;
 594                         }
 595                 AnimDev[wDevID].dwTimeFormat = lpParms->dwTimeFormat;
 596                 }
 597         if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
 598         if (dwFlags & MCI_SET_ON) return MCIERR_UNSUPPORTED_FUNCTION;
 599         if (dwFlags & MCI_SET_OFF) return MCIERR_UNSUPPORTED_FUNCTION;
 600         if (dwFlags & MCI_NOTIFY) {
 601                 dprintf_mcianim(stddeb,
 602                         "ANIM_mciSet // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
 603                         lpParms->dwCallback);
 604                 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 605                         AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 606                 }
 607         return 0;
 608 #else
 609         return MCIERR_HARDWARE;
 610 #endif
 611 }
 612
 613
 614 /**************************************************************************
 615 *                               ANIM_DriverProc         [sample driver]
 616 */
 617 LRESULT ANIM_DriverProc(DWORD dwDevID, HDRVR hDriv, WORD wMsg,
 618                                                         DWORD dwParam1, DWORD dwParam2)
 619 {
 620 #ifdef linux
 621         switch(wMsg) {
 622                 case DRV_LOAD:
 623                         return (LRESULT)1L;
 624                 case DRV_FREE:
 625                         return (LRESULT)1L;
 626                 case DRV_OPEN:
 627                 case MCI_OPEN_DRIVER:
 628                 case MCI_OPEN:
 629                         return ANIM_mciOpen(dwDevID, dwParam1,
 630                                         (LPMCI_OPEN_PARMS)PTR_SEG_TO_LIN(dwParam2));
 631                 case DRV_CLOSE:
 632                 case MCI_CLOSE_DRIVER:
 633                 case MCI_CLOSE:
 634                         return ANIM_mciClose(dwDevID, dwParam1,
 635                                         (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
 636                 case DRV_ENABLE:
 637                         return (LRESULT)1L;
 638                 case DRV_DISABLE:
 639                         return (LRESULT)1L;
 640                 case DRV_QUERYCONFIGURE:
 641                         return (LRESULT)1L;
 642                 case DRV_CONFIGURE:
 643                         MessageBox((HWND)NULL, "Sample MultiMedia Linux Driver !",
 644                                                                 "MMLinux Driver", MB_OK);
 645                         return (LRESULT)1L;
 646                 case DRV_INSTALL:
 647                         return (LRESULT)DRVCNF_RESTART;
 648                 case DRV_REMOVE:
 649                         return (LRESULT)DRVCNF_RESTART;
 650                 case MCI_GETDEVCAPS:
 651                         return ANIM_mciGetDevCaps(dwDevID, dwParam1,
 652                                         (LPMCI_GETDEVCAPS_PARMS)PTR_SEG_TO_LIN(dwParam2));
 653                 case MCI_INFO:
 654                         return ANIM_mciInfo(dwDevID, dwParam1,
 655                                                 (LPMCI_INFO_PARMS)PTR_SEG_TO_LIN(dwParam2));
 656                 case MCI_STATUS:
 657                         return ANIM_mciStatus(dwDevID, dwParam1,
 658                                                 (LPMCI_STATUS_PARMS)PTR_SEG_TO_LIN(dwParam2));
 659                 case MCI_SET:
 660                         return ANIM_mciSet(dwDevID, dwParam1,
 661                                                 (LPMCI_SET_PARMS)PTR_SEG_TO_LIN(dwParam2));
 662                 case MCI_PLAY:
 663                         return ANIM_mciPlay(dwDevID, dwParam1,
 664                                                 (LPMCI_PLAY_PARMS)PTR_SEG_TO_LIN(dwParam2));
 665                 case MCI_STOP:
 666                         return ANIM_mciStop(dwDevID, dwParam1,
 667                                         (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
 668                 case MCI_PAUSE:
 669                         return ANIM_mciPause(dwDevID, dwParam1,
 670                                         (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
 671                 case MCI_RESUME:
 672                         return ANIM_mciResume(dwDevID, dwParam1,
 673                                         (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
 674                 case MCI_SEEK:
 675                         return ANIM_mciSeek(dwDevID, dwParam1,
 676                                         (LPMCI_SEEK_PARMS)PTR_SEG_TO_LIN(dwParam2));
 677                 default:
 678                         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 679                 }
 680 #else
 681         return MCIERR_HARDWARE;
 682 #endif
 683 }
 684
 685
 686 /*-----------------------------------------------------------------------*/
 687
 688 #endif /* #ifdef BUILTIN_MMSYSTEM */