git.oblomov.eu Git - wine/blob - dlls/winmm/mciseq/mcimidi.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * Sample MIDI Wine Driver for Linux
   5  *
   6  * Copyright    1994 Martin Ayotte
   7  *              1999 Eric Pouech
   8  */
   9
  10 /*
  11  * Eric POUECH :
  12  * 98/7 changes for making this MIDI driver work on OSS
  13  *      current support is limited to MIDI ports of OSS systems
  14  * 98/9 rewriting MCI code for MIDI
  15  * 98/11 splitted in midi.c and mcimidi.c
  16  */
  17
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include "windef.h"
  21 #include "wingdi.h"
  22 #include "winuser.h"
  23 #include "mmddk.h"
  24 #include "debugtools.h"
  25
  26 DEFAULT_DEBUG_CHANNEL(mcimidi);
  27
  28 #define MIDI_NOTEOFF             0x80
  29 #define MIDI_NOTEON              0x90
  30
  31 typedef struct {
  32     DWORD               dwFirst;                /* offset in file of track */
  33     DWORD               dwLast;                 /* number of bytes in file of track */
  34     DWORD               dwIndex;                /* current index in file (dwFirst <= dwIndex < dwLast) */
  35     DWORD               dwLength;               /* number of pulses in this track */
  36     DWORD               dwEventPulse;           /* current pulse # (event) pointed by dwIndex */
  37     DWORD               dwEventData;            /* current data    (event) pointed by dwIndex */
  38     WORD                wEventLength;           /* current length  (event) pointed by dwIndex */
  39     WORD                wStatus : 1,            /* 1 : playing, 0 : done */
  40                         wTrackNr : 7,
  41                         wLastCommand : 8;       /* last MIDI command on track */
  42 } MCI_MIDITRACK;
  43
  44 typedef struct tagWINE_MCIMIDI {
  45     UINT                wDevID;                 /* the MCI one */
  46     HMIDI               hMidi;
  47     int                 nUseCount;              /* Incremented for each shared open          */
  48     WORD                wNotifyDeviceID;        /* MCI device ID with a pending notification */
  49     HANDLE              hCallback;              /* Callback handle for pending notification  */
  50     HMMIO               hFile;                  /* mmio file handle open as Element          */
  51     LPSTR               lpstrElementName;       /* Name of file */
  52     LPSTR               lpstrCopyright;
  53     LPSTR               lpstrName;
  54     WORD                dwStatus;               /* one from MCI_MODE_xxxx */
  55     DWORD               dwMciTimeFormat;        /* One of the supported MCI_FORMAT_xxxx */
  56     WORD                wFormat;                /* Format of MIDI hFile (0, 1 or 2) */
  57     WORD                nTracks;                /* Number of tracks in hFile */
  58     WORD                nDivision;              /* Number of division in hFile PPQN or SMPTE */
  59     WORD                wStartedPlaying;
  60     DWORD               dwTempo;                /* Tempo (# of 1/4 note per second */
  61     MCI_MIDITRACK*      tracks;                 /* Content of each track */
  62     DWORD               dwPulse;
  63     DWORD               dwPositionMS;
  64     DWORD               dwStartTicks;
  65 } WINE_MCIMIDI;
  66
  67 /* ===================================================================
  68  * ===================================================================
  69  * FIXME: should be using the new mmThreadXXXX functions from WINMM
  70  * instead of those
  71  * it would require to add a wine internal flag to mmThreadCreate
  72  * in order to pass a 32 bit function instead of a 16 bit
  73  * ===================================================================
  74  * =================================================================== */
  75
  76 struct SCA {
  77     UINT        wDevID;
  78     UINT        wMsg;
  79     DWORD       dwParam1;
  80     DWORD       dwParam2;
  81     BOOL        allocatedCopy;
  82 };
  83
  84 /* EPP DWORD WINAPI mciSendCommandA(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2); */
  85
  86 /**************************************************************************
  87  *                              MCI_SCAStarter                  [internal]
  88  */
  89 static DWORD CALLBACK   MCI_SCAStarter(LPVOID arg)
  90 {
  91     struct SCA* sca = (struct SCA*)arg;
  92     DWORD               ret;
  93
  94     TRACE("In thread before async command (%08x,%u,%08lx,%08lx)\n",
  95           sca->wDevID, sca->wMsg, sca->dwParam1, sca->dwParam2);
  96     ret = mciSendCommandA(sca->wDevID, sca->wMsg, sca->dwParam1 | MCI_WAIT, sca->dwParam2);
  97     TRACE("In thread after async command (%08x,%u,%08lx,%08lx)\n",
  98           sca->wDevID, sca->wMsg, sca->dwParam1, sca->dwParam2);
  99     if (sca->allocatedCopy)
 100         HeapFree(GetProcessHeap(), 0, (LPVOID)sca->dwParam2);
 101     HeapFree(GetProcessHeap(), 0, sca);
 102     ExitThread(ret);
 103     WARN("Should not happen ? what's wrong \n");
 104     /* should not go after this point */
 105     return ret;
 106 }
 107
 108 /**************************************************************************
 109  *                              MCI_SendCommandAsync            [internal]
 110  */
 111 static  DWORD MCI_SendCommandAsync(UINT wDevID, UINT wMsg, DWORD dwParam1,
 112                                    DWORD dwParam2, UINT size)
 113 {
 114     struct SCA* sca = HeapAlloc(GetProcessHeap(), 0, sizeof(struct SCA));
 115
 116     if (sca == 0)
 117         return MCIERR_OUT_OF_MEMORY;
 118
 119     sca->wDevID   = wDevID;
 120     sca->wMsg     = wMsg;
 121     sca->dwParam1 = dwParam1;
 122
 123     if (size) {
 124         sca->dwParam2 = (DWORD)HeapAlloc(GetProcessHeap(), 0, size);
 125         if (sca->dwParam2 == 0) {
 126             HeapFree(GetProcessHeap(), 0, sca);
 127             return MCIERR_OUT_OF_MEMORY;
 128         }
 129         sca->allocatedCopy = TRUE;
 130         /* copy structure passed by program in dwParam2 to be sure
 131          * we can still use it whatever the program does
 132          */
 133         memcpy((LPVOID)sca->dwParam2, (LPVOID)dwParam2, size);
 134     } else {
 135         sca->dwParam2 = dwParam2;
 136         sca->allocatedCopy = FALSE;
 137     }
 138
 139     if (CreateThread(NULL, 0, MCI_SCAStarter, sca, 0, NULL) == 0) {
 140         WARN("Couldn't allocate thread for async command handling, sending synchonously\n");
 141         return MCI_SCAStarter(&sca);
 142     }
 143     return 0;
 144 }
 145
 146 /*======================================================================*
 147  *                          MCI MIDI implemantation                     *
 148  *======================================================================*/
 149
 150 static DWORD MIDI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
 151
 152 /**************************************************************************
 153  *                              MIDI_drvOpen                    [internal]
 154  */
 155 static  DWORD   MIDI_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
 156 {
 157     WINE_MCIMIDI*       wmm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIMIDI));
 158
 159     if (!wmm)
 160         return 0;
 161
 162     wmm->wDevID = modp->wDeviceID;
 163     mciSetDriverData(wmm->wDevID, (DWORD)wmm);
 164     modp->wCustomCommandTable = MCI_NO_COMMAND_TABLE;
 165     modp->wType = MCI_DEVTYPE_SEQUENCER;
 166     return modp->wDeviceID;
 167 }
 168
 169 /**************************************************************************
 170  *                              MCIMIDI_drvClose                [internal]
 171  */
 172 static  DWORD   MIDI_drvClose(DWORD dwDevID)
 173 {
 174     WINE_MCIMIDI*  wmm = (WINE_MCIMIDI*)mciGetDriverData(dwDevID);
 175
 176     if (wmm) {
 177         HeapFree(GetProcessHeap(), 0, wmm);
 178         mciSetDriverData(dwDevID, 0);
 179         return 1;
 180     }
 181     return 0;
 182 }
 183
 184 /**************************************************************************
 185  *                              MIDI_mciGetOpenDev              [internal]
 186  */
 187 static WINE_MCIMIDI*  MIDI_mciGetOpenDev(UINT wDevID)
 188 {
 189     WINE_MCIMIDI*       wmm = (WINE_MCIMIDI*)mciGetDriverData(wDevID);
 190
 191     if (wmm == NULL || wmm->nUseCount == 0) {
 192         WARN("Invalid wDevID=%u\n", wDevID);
 193         return 0;
 194     }
 195     return wmm;
 196 }
 197
 198 /**************************************************************************
 199  *                              MIDI_mciReadByte                [internal]
 200  */
 201 static DWORD MIDI_mciReadByte(WINE_MCIMIDI* wmm, BYTE *lpbyt)
 202 {
 203     DWORD       ret = 0;
 204
 205     if (lpbyt == NULL ||
 206         mmioRead(wmm->hFile, (HPSTR)lpbyt, sizeof(BYTE)) != (long)sizeof(BYTE)) {
 207         WARN("Error reading wmm=%p\n", wmm);
 208         ret = MCIERR_INVALID_FILE;
 209     }
 210
 211     return ret;
 212 }
 213
 214 /**************************************************************************
 215  *                              MIDI_mciReadWord                [internal]
 216  */
 217 static DWORD MIDI_mciReadWord(WINE_MCIMIDI* wmm, LPWORD lpw)
 218 {
 219     BYTE        hibyte, lobyte;
 220     DWORD       ret = MCIERR_INVALID_FILE;
 221
 222     if (lpw != NULL &&
 223         MIDI_mciReadByte(wmm, &hibyte) == 0 &&
 224         MIDI_mciReadByte(wmm, &lobyte) == 0) {
 225         *lpw = ((WORD)hibyte << 8) + lobyte;
 226         ret = 0;
 227     }
 228     return ret;
 229 }
 230
 231 /**************************************************************************
 232  *                              MIDI_mciReadLong                [internal]
 233  */
 234 static DWORD MIDI_mciReadLong(WINE_MCIMIDI* wmm, LPDWORD lpdw)
 235 {
 236     WORD        hiword, loword;
 237     DWORD       ret = MCIERR_INVALID_FILE;
 238
 239     if (lpdw != NULL &&
 240         MIDI_mciReadWord(wmm, &hiword) == 0 &&
 241         MIDI_mciReadWord(wmm, &loword) == 0) {
 242         *lpdw = MAKELONG(loword, hiword);
 243         ret = 0;
 244     }
 245     return ret;
 246 }
 247
 248 /**************************************************************************
 249  *                              MIDI_mciReadVaryLen             [internal]
 250  */
 251 static WORD MIDI_mciReadVaryLen(WINE_MCIMIDI* wmm, LPDWORD lpdw)
 252 {
 253     BYTE        byte;
 254     DWORD       value = 0;
 255     WORD        ret = 0;
 256
 257     if (lpdw == NULL) {
 258         ret = MCIERR_INVALID_FILE;
 259     } else {
 260         do {
 261             if (MIDI_mciReadByte(wmm, &byte) != 0) {
 262                 return 0;
 263             }
 264             value = (value << 7) + (byte & 0x7F);
 265             ret++;
 266         } while (byte & 0x80);
 267         *lpdw = value;
 268         /*
 269           TRACE("val=%08lX \n", value);
 270         */
 271     }
 272     return ret;
 273 }
 274
 275 /**************************************************************************
 276  *                              MIDI_mciReadNextEvent           [internal]
 277  */
 278 static DWORD    MIDI_mciReadNextEvent(WINE_MCIMIDI* wmm, MCI_MIDITRACK* mmt)
 279 {
 280     BYTE        b1, b2 = 0, b3;
 281     WORD        hw = 0;
 282     DWORD       evtPulse;
 283     DWORD       evtLength;
 284     DWORD       tmp;
 285
 286     if (mmioSeek(wmm->hFile, mmt->dwIndex, SEEK_SET) != mmt->dwIndex) {
 287         WARN("Can't seek at %08lX \n", mmt->dwIndex);
 288         return MCIERR_INVALID_FILE;
 289     }
 290     evtLength = MIDI_mciReadVaryLen(wmm, &evtPulse) + 1;        /* > 0 */
 291     MIDI_mciReadByte(wmm, &b1);
 292     switch (b1) {
 293     case 0xF0:
 294     case 0xF7:
 295         evtLength += MIDI_mciReadVaryLen(wmm, &tmp);
 296         evtLength += tmp;
 297         break;
 298     case 0xFF:
 299         MIDI_mciReadByte(wmm, &b2);     evtLength++;
 300
 301         evtLength += MIDI_mciReadVaryLen(wmm, &tmp);
 302         if (evtLength >= 0x10000u) {
 303             /* this limitation shouldn't be a problem */
 304             WARN("Ouch !! Implementation limitation to 64k bytes for a MIDI event is overflowed\n");
 305             hw = 0xFFFF;
 306         } else {
 307             hw = LOWORD(evtLength);
 308         }
 309         evtLength += tmp;
 310         break;
 311     default:
 312         if (b1 & 0x80) { /* use running status ? */
 313             mmt->wLastCommand = b1;
 314             MIDI_mciReadByte(wmm, &b2); evtLength++;
 315         } else {
 316             b2 = b1;
 317             b1 = mmt->wLastCommand;
 318         }
 319         switch ((b1 >> 4) & 0x07) {
 320         case 0: case 1: case 2: case 3: case 6:
 321             MIDI_mciReadByte(wmm, &b3); evtLength++;
 322             hw = b3;
 323             break;
 324         case 4: case 5:
 325             break;
 326         case 7:
 327             WARN("Strange indeed b1=0x%02x\n", b1);
 328         }
 329         break;
 330     }
 331     if (mmt->dwIndex + evtLength > mmt->dwLast)
 332         return MCIERR_INTERNAL;
 333
 334     mmt->dwEventPulse += evtPulse;
 335     mmt->dwEventData   = (hw << 16) + (b2 << 8) + b1;
 336     mmt->wEventLength  = evtLength;
 337
 338     /*
 339       TRACE("[%u] => pulse=%08lx(%08lx), data=%08lx, length=%u\n",
 340       mmt->wTrackNr, mmt->dwEventPulse, evtPulse,
 341       mmt->dwEventData, mmt->wEventLength);
 342     */
 343     return 0;
 344 }
 345
 346 /**************************************************************************
 347  *                              MIDI_mciReadMTrk                [internal]
 348  */
 349 static DWORD MIDI_mciReadMTrk(WINE_MCIMIDI* wmm, MCI_MIDITRACK* mmt)
 350 {
 351     DWORD               toberead;
 352     FOURCC              fourcc;
 353
 354     if (mmioRead(wmm->hFile, (HPSTR)&fourcc, (long)sizeof(FOURCC)) !=
 355         (long)sizeof(FOURCC)) {
 356         return MCIERR_INVALID_FILE;
 357     }
 358
 359     if (fourcc != mmioFOURCC('M', 'T', 'r', 'k')) {
 360         WARN("Can't synchronize on 'MTrk' !\n");
 361         return MCIERR_INVALID_FILE;
 362     }
 363
 364     if (MIDI_mciReadLong(wmm, &toberead) != 0) {
 365         return MCIERR_INVALID_FILE;
 366     }
 367     mmt->dwFirst = mmioSeek(wmm->hFile, 0, SEEK_CUR); /* >= 0 */
 368     mmt->dwLast = mmt->dwFirst + toberead;
 369
 370     /* compute # of pulses in this track */
 371     mmt->dwIndex = mmt->dwFirst;
 372     mmt->dwEventPulse = 0;
 373
 374     while (MIDI_mciReadNextEvent(wmm, mmt) == 0 && LOWORD(mmt->dwEventData) != 0x2FFF) {
 375         char    buf[1024];
 376         WORD    len;
 377
 378         mmt->dwIndex += mmt->wEventLength;
 379
 380         switch (LOWORD(mmt->dwEventData)) {
 381         case 0x02FF:
 382         case 0x03FF:
 383             /* position after meta data header */
 384             mmioSeek(wmm->hFile, mmt->dwIndex + HIWORD(mmt->dwEventData), SEEK_SET);
 385             len = mmt->wEventLength - HIWORD(mmt->dwEventData);
 386
 387             if (len >= sizeof(buf)) {
 388                 WARN("Buffer for text is too small (%d bytes, when %u are needed)\n", sizeof(buf) - 1, len);
 389                 len = sizeof(buf) - 1;
 390             }
 391             if (mmioRead(wmm->hFile, (HPSTR)buf, len) == len) {
 392                 buf[len] = 0;   /* end string in case */
 393                 switch (HIBYTE(LOWORD(mmt->dwEventData))) {
 394                 case 0x02:
 395                     if (wmm->lpstrCopyright) {
 396                         WARN("Two copyright notices (%s|%s)\n", wmm->lpstrCopyright, buf);
 397                     } else {
 398                         wmm->lpstrCopyright = HeapAlloc( GetProcessHeap(), 0, strlen(buf)+1 );
 399                         strcpy( wmm->lpstrCopyright, buf );
 400                     }
 401                     break;
 402                 case 0x03:
 403                     if (wmm->lpstrCopyright) {
 404                         WARN("Two names (%s|%s)\n", wmm->lpstrName, buf);
 405                     } else {
 406                         wmm->lpstrName = HeapAlloc( GetProcessHeap(), 0, strlen(buf)+1 );
 407                         strcpy( wmm->lpstrName, buf );
 408                     }
 409                     break;
 410                 }
 411             }
 412             break;
 413         }
 414     }
 415     mmt->dwLength = mmt->dwEventPulse;
 416
 417     TRACE("Track %u has %lu bytes and %lu pulses\n", mmt->wTrackNr, toberead, mmt->dwLength);
 418
 419     /* reset track data */
 420     mmt->wStatus = 1;   /* ok, playing */
 421     mmt->dwIndex = mmt->dwFirst;
 422     mmt->dwEventPulse = 0;
 423
 424     if (mmioSeek(wmm->hFile, 0, SEEK_CUR) != mmt->dwLast) {
 425         WARN("Ouch, out of sync seek=%lu track=%lu\n",
 426              mmioSeek(wmm->hFile, 0, SEEK_CUR), mmt->dwLast);
 427         /* position at end of this track, to be ready to read next track */
 428         mmioSeek(wmm->hFile, mmt->dwLast, SEEK_SET);
 429     }
 430
 431     return 0;
 432 }
 433
 434 /**************************************************************************
 435  *                              MIDI_mciReadMThd                [internal]
 436  */
 437 static DWORD MIDI_mciReadMThd(WINE_MCIMIDI* wmm, DWORD dwOffset)
 438 {
 439     DWORD       toberead;
 440     FOURCC      fourcc;
 441     WORD        nt;
 442
 443     TRACE("(%p, %08lX);\n", wmm, dwOffset);
 444
 445     if (mmioSeek(wmm->hFile, dwOffset, SEEK_SET) != dwOffset) {
 446         WARN("Can't seek at %08lX begin of 'MThd' \n", dwOffset);
 447         return MCIERR_INVALID_FILE;
 448     }
 449     if (mmioRead(wmm->hFile, (HPSTR)&fourcc,
 450                    (long) sizeof(FOURCC)) != (long) sizeof(FOURCC))
 451         return MCIERR_INVALID_FILE;
 452
 453     if (fourcc != mmioFOURCC('M', 'T', 'h', 'd')) {
 454         WARN("Can't synchronize on 'MThd' !\n");
 455         return MCIERR_INVALID_FILE;
 456     }
 457
 458     if (MIDI_mciReadLong(wmm, &toberead) != 0 || toberead < 3 * sizeof(WORD))
 459         return MCIERR_INVALID_FILE;
 460
 461     if (MIDI_mciReadWord(wmm, &wmm->wFormat) != 0 ||
 462         MIDI_mciReadWord(wmm, &wmm->nTracks) != 0 ||
 463         MIDI_mciReadWord(wmm, &wmm->nDivision) != 0) {
 464         return MCIERR_INVALID_FILE;
 465     }
 466
 467     TRACE("toberead=0x%08lX, wFormat=0x%04X nTracks=0x%04X nDivision=0x%04X\n",
 468           toberead, wmm->wFormat, wmm->nTracks, wmm->nDivision);
 469
 470     /* MS doc says that the MIDI MCI time format must be put by default to the format
 471      * stored in the MIDI file...
 472      */
 473     if (wmm->nDivision > 0x8000) {
 474         /* eric.pouech@lemel.fr 98/11
 475          * In did not check this very code (pulses are expressed as SMPTE sub-frames).
 476          * In about 40 MB of MIDI files I have, none was SMPTE based...
 477          * I'm just wondering if this is widely used :-). So, if someone has one of
 478          * these files, I'd like to know about.
 479          */
 480         FIXME("Handling SMPTE time in MIDI files has not been tested\n"
 481               "Please report to comp.emulators.ms-windows.wine with MIDI file !\n");
 482
 483         switch (HIBYTE(wmm->nDivision)) {
 484         case 0xE8:      wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_24;     break;  /* -24 */
 485         case 0xE7:      wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_25;     break;  /* -25 */
 486         case 0xE3:      wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_30DROP; break;  /* -29 */ /* is the MCI constant correct ? */
 487         case 0xE2:      wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_30;     break;  /* -30 */
 488         default:
 489             WARN("Unsupported number of frames %d\n", -(char)HIBYTE(wmm->nDivision));
 490             return MCIERR_INVALID_FILE;
 491         }
 492         switch (LOBYTE(wmm->nDivision)) {
 493         case 4: /* MIDI Time Code */
 494         case 8:
 495         case 10:
 496         case 80: /* SMPTE bit resolution */
 497         case 100:
 498         default:
 499             WARN("Unsupported number of sub-frames %d\n", LOBYTE(wmm->nDivision));
 500             return MCIERR_INVALID_FILE;
 501         }
 502     } else if (wmm->nDivision == 0) {
 503         WARN("Number of division is 0, can't support that !!\n");
 504         return MCIERR_INVALID_FILE;
 505     } else {
 506         wmm->dwMciTimeFormat = MCI_FORMAT_MILLISECONDS;
 507     }
 508
 509     switch (wmm->wFormat) {
 510     case 0:
 511         if (wmm->nTracks != 1) {
 512             WARN("Got type 0 file whose number of track is not 1. Setting it to 1\n");
 513             wmm->nTracks = 1;
 514         }
 515         break;
 516     case 1:
 517     case 2:
 518         break;
 519     default:
 520         WARN("Handling MIDI files which format = %d is not (yet) supported\n"
 521              "Please report with MIDI file !\n", wmm->wFormat);
 522         return MCIERR_INVALID_FILE;
 523     }
 524
 525     if (wmm->nTracks & 0x8000) {
 526         /* this shouldn't be a problem... */
 527         WARN("Ouch !! Implementation limitation to 32k tracks per MIDI file is overflowed\n");
 528         wmm->nTracks = 0x7FFF;
 529     }
 530
 531     if ((wmm->tracks = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_MIDITRACK) * wmm->nTracks)) == NULL) {
 532         return MCIERR_OUT_OF_MEMORY;
 533     }
 534
 535     toberead -= 3 * sizeof(WORD);
 536     if (toberead > 0) {
 537         TRACE("Size of MThd > 6, skipping %ld extra bytes\n", toberead);
 538         mmioSeek(wmm->hFile, toberead, SEEK_CUR);
 539     }
 540
 541     for (nt = 0; nt < wmm->nTracks; nt++) {
 542         wmm->tracks[nt].wTrackNr = nt;
 543         if (MIDI_mciReadMTrk(wmm, &wmm->tracks[nt]) != 0) {
 544             WARN("Can't read 'MTrk' header \n");
 545             return MCIERR_INVALID_FILE;
 546         }
 547     }
 548
 549     wmm->dwTempo = 500000;
 550
 551     return 0;
 552 }
 553
 554 /**************************************************************************
 555  *                      MIDI_ConvertPulseToMS                   [internal]
 556  */
 557 static  DWORD   MIDI_ConvertPulseToMS(WINE_MCIMIDI* wmm, DWORD pulse)
 558 {
 559     DWORD       ret = 0;
 560
 561     /* FIXME: this function may return false values since the tempo (wmm->dwTempo)
 562      * may change during file playing
 563      */
 564     if (wmm->nDivision == 0) {
 565         FIXME("Shouldn't happen. wmm->nDivision = 0\n");
 566     } else if (wmm->nDivision > 0x8000) { /* SMPTE, unchecked FIXME? */
 567         int     nf = -(char)HIBYTE(wmm->nDivision);     /* number of frames     */
 568         int     nsf = LOBYTE(wmm->nDivision);           /* number of sub-frames */
 569         ret = (pulse * 1000) / (nf * nsf);
 570     } else {
 571         ret = (DWORD)((double)pulse * ((double)wmm->dwTempo / 1000) /
 572                       (double)wmm->nDivision);
 573     }
 574
 575     /*
 576       TRACE("pulse=%lu tempo=%lu division=%u=0x%04x => ms=%lu\n",
 577       pulse, wmm->dwTempo, wmm->nDivision, wmm->nDivision, ret);
 578     */
 579
 580     return ret;
 581 }
 582
 583 #define TIME_MS_IN_ONE_HOUR     (60*60*1000)
 584 #define TIME_MS_IN_ONE_MINUTE   (60*1000)
 585 #define TIME_MS_IN_ONE_SECOND   (1000)
 586
 587 /**************************************************************************
 588  *                      MIDI_ConvertTimeFormatToMS              [internal]
 589  */
 590 static  DWORD   MIDI_ConvertTimeFormatToMS(WINE_MCIMIDI* wmm, DWORD val)
 591 {
 592     DWORD       ret = 0;
 593
 594     switch (wmm->dwMciTimeFormat) {
 595     case MCI_FORMAT_MILLISECONDS:
 596         ret = val;
 597         break;
 598     case MCI_FORMAT_SMPTE_24:
 599         ret =
 600             (HIBYTE(HIWORD(val)) * 125) / 3 +             LOBYTE(HIWORD(val)) * TIME_MS_IN_ONE_SECOND +
 601             HIBYTE(LOWORD(val)) * TIME_MS_IN_ONE_MINUTE + LOBYTE(LOWORD(val)) * TIME_MS_IN_ONE_HOUR;
 602         break;
 603     case MCI_FORMAT_SMPTE_25:
 604         ret =
 605             HIBYTE(HIWORD(val)) * 40 +                    LOBYTE(HIWORD(val)) * TIME_MS_IN_ONE_SECOND +
 606             HIBYTE(LOWORD(val)) * TIME_MS_IN_ONE_MINUTE + LOBYTE(LOWORD(val)) * TIME_MS_IN_ONE_HOUR;
 607         break;
 608     case MCI_FORMAT_SMPTE_30:
 609         ret =
 610             (HIBYTE(HIWORD(val)) * 100) / 3 +             LOBYTE(HIWORD(val)) * TIME_MS_IN_ONE_SECOND +
 611             HIBYTE(LOWORD(val)) * TIME_MS_IN_ONE_MINUTE + LOBYTE(LOWORD(val)) * TIME_MS_IN_ONE_HOUR;
 612         break;
 613     default:
 614         WARN("Bad time format %lu!\n", wmm->dwMciTimeFormat);
 615     }
 616     /*
 617       TRACE("val=%lu=0x%08lx [tf=%lu] => ret=%lu\n", val, val, wmm->dwMciTimeFormat, ret);
 618     */
 619     return ret;
 620 }
 621
 622 /**************************************************************************
 623  *                      MIDI_ConvertMSToTimeFormat              [internal]
 624  */
 625 static  DWORD   MIDI_ConvertMSToTimeFormat(WINE_MCIMIDI* wmm, DWORD _val)
 626 {
 627     DWORD       ret = 0, val = _val;
 628     DWORD       h, m, s, f;
 629
 630     switch (wmm->dwMciTimeFormat) {
 631     case MCI_FORMAT_MILLISECONDS:
 632         ret = val;
 633         break;
 634     case MCI_FORMAT_SMPTE_24:
 635     case MCI_FORMAT_SMPTE_25:
 636     case MCI_FORMAT_SMPTE_30:
 637         h = val / TIME_MS_IN_ONE_HOUR;
 638         m = (val -= h * TIME_MS_IN_ONE_HOUR)   / TIME_MS_IN_ONE_MINUTE;
 639         s = (val -= m * TIME_MS_IN_ONE_MINUTE) / TIME_MS_IN_ONE_SECOND;
 640         switch (wmm->dwMciTimeFormat) {
 641         case MCI_FORMAT_SMPTE_24:
 642             /* one frame is 1000/24 val long, 1000/24 == 125/3 */
 643             f = (val * 3) / 125;        val -= (f * 125) / 3;
 644             break;
 645         case MCI_FORMAT_SMPTE_25:
 646             /* one frame is 1000/25 ms long, 1000/25 == 40 */
 647             f = val / 40;               val -= f * 40;
 648             break;
 649         case MCI_FORMAT_SMPTE_30:
 650             /* one frame is 1000/30 ms long, 1000/30 == 100/3 */
 651             f = (val * 3) / 100;        val -= (f * 100) / 3;
 652             break;
 653         default:
 654             FIXME("There must be some bad bad programmer\n");
 655             f = 0;
 656         }
 657         /* val contains the number of ms which cannot make a complete frame */
 658         /* FIXME: is this correct ? programs seem to be happy with that */
 659         ret = (f << 24) | (s << 16) | (m << 8) | (h << 0);
 660         break;
 661     default:
 662         WARN("Bad time format %lu!\n", wmm->dwMciTimeFormat);
 663     }
 664     /*
 665       TRACE("val=%lu [tf=%lu] => ret=%lu=0x%08lx\n", _val, wmm->dwMciTimeFormat, ret, ret);
 666     */
 667     return ret;
 668 }
 669
 670 /**************************************************************************
 671  *                      MIDI_GetMThdLengthMS                    [internal]
 672  */
 673 static  DWORD   MIDI_GetMThdLengthMS(WINE_MCIMIDI* wmm)
 674 {
 675     WORD        nt;
 676     DWORD       ret = 0;
 677
 678     for (nt = 0; nt < wmm->nTracks; nt++) {
 679         if (wmm->wFormat == 2) {
 680             ret += wmm->tracks[nt].dwLength;
 681         } else if (wmm->tracks[nt].dwLength > ret) {
 682             ret = wmm->tracks[nt].dwLength;
 683         }
 684     }
 685     /* FIXME: this is wrong if there is a tempo change inside the file */
 686     return MIDI_ConvertPulseToMS(wmm, ret);
 687 }
 688
 689 /**************************************************************************
 690  *                              MIDI_mciOpen                    [internal]
 691  */
 692 static DWORD MIDI_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_OPEN_PARMSA lpParms)
 693 {
 694     DWORD               dwRet = 0;
 695     DWORD               dwDeviceID;
 696     WINE_MCIMIDI*       wmm = (WINE_MCIMIDI*)mciGetDriverData(wDevID);
 697
 698     TRACE("(%04x, %08lX, %p)\n", wDevID, dwFlags, lpParms);
 699
 700     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 701     if (wmm == NULL)            return MCIERR_INVALID_DEVICE_ID;
 702     if (dwFlags & MCI_OPEN_SHAREABLE)
 703         return MCIERR_HARDWARE;
 704
 705     if (wmm->nUseCount > 0) {
 706         /* The driver is already opened on this channel
 707          * MIDI sequencer cannot be shared
 708          */
 709         return MCIERR_DEVICE_OPEN;
 710     }
 711     wmm->nUseCount++;
 712
 713     wmm->hFile = 0;
 714     wmm->hMidi = 0;
 715     dwDeviceID = lpParms->wDeviceID;
 716
 717     TRACE("wDevID=%04X (lpParams->wDeviceID=%08lX)\n", wDevID, dwDeviceID);
 718     /*  lpParms->wDeviceID = wDevID;*/
 719
 720     if (dwFlags & MCI_OPEN_ELEMENT) {
 721         TRACE("MCI_OPEN_ELEMENT '%s' !\n", lpParms->lpstrElementName);
 722         if (lpParms->lpstrElementName && strlen(lpParms->lpstrElementName) > 0) {
 723             wmm->hFile = mmioOpenA(lpParms->lpstrElementName, NULL,
 724                                    MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
 725             if (wmm->hFile == 0) {
 726                 WARN("Can't find file '%s' !\n", lpParms->lpstrElementName);
 727                 wmm->nUseCount--;
 728                 return MCIERR_FILE_NOT_FOUND;
 729             }
 730         } else {
 731             wmm->hFile = 0;
 732         }
 733     }
 734     TRACE("hFile=%u\n", wmm->hFile);
 735
 736     /* FIXME: should I get a strdup() of it instead? */
 737     wmm->lpstrElementName = HeapAlloc( GetProcessHeap(), 0, strlen(lpParms->lpstrElementName)+1 );
 738     strcpy( wmm->lpstrElementName, lpParms->lpstrElementName );
 739     wmm->lpstrCopyright = NULL;
 740     wmm->lpstrName = NULL;
 741
 742     wmm->wNotifyDeviceID = dwDeviceID;
 743     wmm->dwStatus = MCI_MODE_NOT_READY; /* while loading file contents */
 744     /* spec says it should be the default format from the MIDI file... */
 745     wmm->dwMciTimeFormat = MCI_FORMAT_MILLISECONDS;
 746
 747     if (wmm->hFile != 0) {
 748         MMCKINFO        ckMainRIFF;
 749         MMCKINFO        mmckInfo;
 750         DWORD           dwOffset = 0;
 751
 752         if (mmioDescend(wmm->hFile, &ckMainRIFF, NULL, 0) != 0) {
 753             dwRet = MCIERR_INVALID_FILE;
 754         } else {
 755             TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
 756                   (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize);
 757
 758             if (ckMainRIFF.ckid == FOURCC_RIFF && ckMainRIFF.fccType == mmioFOURCC('R', 'M', 'I', 'D')) {
 759                 mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
 760                 mmioSeek(wmm->hFile, ckMainRIFF.dwDataOffset + ((ckMainRIFF.cksize + 1) & ~1), SEEK_SET);
 761                 if (mmioDescend(wmm->hFile, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0) {
 762                     TRACE("... is a 'RMID' file \n");
 763                     dwOffset = mmckInfo.dwDataOffset;
 764                 } else {
 765                     dwRet = MCIERR_INVALID_FILE;
 766                 }
 767             }
 768             if (dwRet == 0 && MIDI_mciReadMThd(wmm, dwOffset) != 0) {
 769                 WARN("Can't read 'MThd' header \n");
 770                 dwRet = MCIERR_INVALID_FILE;
 771             }
 772         }
 773     } else {
 774         TRACE("hFile==0, setting #tracks to 0; is this correct ?\n");
 775         wmm->nTracks = 0;
 776         wmm->wFormat = 0;
 777         wmm->nDivision = 1;
 778     }
 779     if (dwRet != 0) {
 780         wmm->nUseCount--;
 781         if (wmm->hFile != 0)
 782             mmioClose(wmm->hFile, 0);
 783         wmm->hFile = 0;
 784     } else {
 785         wmm->dwPositionMS = 0;
 786         wmm->dwStatus = MCI_MODE_STOP;
 787     }
 788     return dwRet;
 789 }
 790
 791 /**************************************************************************
 792  *                              MIDI_mciStop                    [internal]
 793  */
 794 static DWORD MIDI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 795 {
 796     WINE_MCIMIDI*       wmm = MIDI_mciGetOpenDev(wDevID);
 797     DWORD               dwRet = 0;
 798
 799     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 800
 801     if (wmm == NULL)    return MCIERR_INVALID_DEVICE_ID;
 802
 803     if (wmm->dwStatus != MCI_MODE_STOP) {
 804         int     oldstat = wmm->dwStatus;
 805
 806         wmm->dwStatus = MCI_MODE_NOT_READY;
 807         if (oldstat == MCI_MODE_PAUSE)
 808             dwRet = midiOutReset(wmm->hMidi);
 809
 810         while (wmm->dwStatus != MCI_MODE_STOP)
 811             Sleep(10);
 812     }
 813
 814     /* sanitiy reset */
 815     wmm->dwStatus = MCI_MODE_STOP;
 816
 817     TRACE("wmm->dwStatus=%d\n", wmm->dwStatus);
 818
 819     if (lpParms && (dwFlags & MCI_NOTIFY)) {
 820         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 821         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 822                         wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 823     }
 824     return 0;
 825 }
 826
 827 /**************************************************************************
 828  *                              MIDI_mciClose                   [internal]
 829  */
 830 static DWORD MIDI_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 831 {
 832     WINE_MCIMIDI*       wmm = MIDI_mciGetOpenDev(wDevID);
 833
 834     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 835
 836     if (wmm == NULL)    return MCIERR_INVALID_DEVICE_ID;
 837
 838     if (wmm->dwStatus != MCI_MODE_STOP) {
 839         MIDI_mciStop(wDevID, MCI_WAIT, lpParms);
 840     }
 841
 842     wmm->nUseCount--;
 843     if (wmm->nUseCount == 0) {
 844         if (wmm->hFile != 0) {
 845             mmioClose(wmm->hFile, 0);
 846             wmm->hFile = 0;
 847             TRACE("hFile closed !\n");
 848         }
 849         HeapFree(GetProcessHeap(), 0, wmm->tracks);
 850         HeapFree(GetProcessHeap(), 0, (LPSTR)wmm->lpstrElementName);
 851         HeapFree(GetProcessHeap(), 0, (LPSTR)wmm->lpstrCopyright);
 852         HeapFree(GetProcessHeap(), 0, (LPSTR)wmm->lpstrName);
 853     } else {
 854         TRACE("Shouldn't happen... nUseCount=%d\n", wmm->nUseCount);
 855         return MCIERR_INTERNAL;
 856     }
 857
 858     if (lpParms && (dwFlags & MCI_NOTIFY)) {
 859         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 860         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 861                         wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 862     }
 863     return 0;
 864 }
 865
 866 /**************************************************************************
 867  *                              MIDI_mciFindNextEvent           [internal]
 868  */
 869 static MCI_MIDITRACK*   MIDI_mciFindNextEvent(WINE_MCIMIDI* wmm, LPDWORD hiPulse)
 870 {
 871     WORD                cnt, nt;
 872     MCI_MIDITRACK*      mmt;
 873
 874     *hiPulse = 0xFFFFFFFFul;
 875     cnt = 0xFFFFu;
 876     for (nt = 0; nt < wmm->nTracks; nt++) {
 877         mmt = &wmm->tracks[nt];
 878
 879         if (mmt->wStatus == 0)
 880             continue;
 881         if (mmt->dwEventPulse < *hiPulse) {
 882             *hiPulse = mmt->dwEventPulse;
 883             cnt = nt;
 884         }
 885     }
 886     return (cnt == 0xFFFFu) ? 0 /* no more event on all tracks */
 887         : &wmm->tracks[cnt];
 888 }
 889
 890 /**************************************************************************
 891  *                              MIDI_mciPlay                    [internal]
 892  */
 893 static DWORD MIDI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
 894 {
 895     DWORD               dwStartMS, dwEndMS;
 896     DWORD               dwRet = 0;
 897     WORD                doPlay, nt;
 898     MCI_MIDITRACK*      mmt;
 899     DWORD               hiPulse;
 900     WINE_MCIMIDI*       wmm = MIDI_mciGetOpenDev(wDevID);
 901
 902     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 903
 904     if (wmm == NULL)    return MCIERR_INVALID_DEVICE_ID;
 905
 906     if (wmm->hFile == 0) {
 907         WARN("Can't play: no file '%s' !\n", wmm->lpstrElementName);
 908         return MCIERR_FILE_NOT_FOUND;
 909     }
 910
 911     if (wmm->dwStatus != MCI_MODE_STOP) {
 912         if (wmm->dwStatus == MCI_MODE_PAUSE) {
 913             /* FIXME: parameters (start/end) in lpParams may not be used */
 914             return MIDI_mciResume(wDevID, dwFlags, (LPMCI_GENERIC_PARMS)lpParms);
 915         }
 916         WARN("Can't play: device is not stopped !\n");
 917         return MCIERR_INTERNAL;
 918     }
 919
 920     if (!(dwFlags & MCI_WAIT)) {
 921         /** FIXME: I'm not 100% sure that wNotifyDeviceID is the right value in all cases ??? */
 922         return MCI_SendCommandAsync(wmm->wNotifyDeviceID, MCI_PLAY, dwFlags, (DWORD)lpParms, sizeof(LPMCI_PLAY_PARMS));
 923     }
 924
 925     if (lpParms && (dwFlags & MCI_FROM)) {
 926         dwStartMS = MIDI_ConvertTimeFormatToMS(wmm, lpParms->dwFrom);
 927     } else {
 928         dwStartMS = wmm->dwPositionMS;
 929     }
 930
 931     if (lpParms && (dwFlags & MCI_TO)) {
 932         dwEndMS = MIDI_ConvertTimeFormatToMS(wmm, lpParms->dwTo);
 933     } else {
 934         dwEndMS = 0xFFFFFFFFul;
 935     }
 936
 937     TRACE("Playing from %lu to %lu\n", dwStartMS, dwEndMS);
 938
 939     /* init tracks */
 940     for (nt = 0; nt < wmm->nTracks; nt++) {
 941         mmt = &wmm->tracks[nt];
 942
 943         mmt->wStatus = 1;       /* ok, playing */
 944         mmt->dwIndex = mmt->dwFirst;
 945         if (wmm->wFormat == 2 && nt > 0) {
 946             mmt->dwEventPulse = wmm->tracks[nt - 1].dwLength;
 947         } else {
 948             mmt->dwEventPulse = 0;
 949         }
 950         MIDI_mciReadNextEvent(wmm, mmt); /* FIXME == 0 */
 951     }
 952
 953     wmm->dwPulse = 0;
 954     wmm->dwTempo = 500000;
 955     wmm->dwStatus = MCI_MODE_PLAY;
 956     wmm->dwPositionMS = 0;
 957     wmm->wStartedPlaying = FALSE;
 958
 959     dwRet = midiOutOpen(&wmm->hMidi, MIDIMAPPER, 0L, 0L, CALLBACK_NULL);
 960     /*  dwRet = midiInOpen(&wmm->hMidi, MIDIMAPPER, 0L, 0L, CALLBACK_NULL);*/
 961
 962     while (wmm->dwStatus != MCI_MODE_STOP && wmm->dwStatus != MCI_MODE_NOT_READY) {
 963         /* it seems that in case of multi-threading, gcc is optimizing just a little bit
 964          * too much. Tell gcc not to optimize status value using volatile.
 965          */
 966         while (((volatile WINE_MCIMIDI*)wmm)->dwStatus == MCI_MODE_PAUSE);
 967
 968         doPlay = (wmm->dwPositionMS >= dwStartMS && wmm->dwPositionMS <= dwEndMS);
 969
 970         TRACE("wmm->dwStatus=%d, doPlay=%c\n", wmm->dwStatus, doPlay ? 'T' : 'F');
 971
 972         if ((mmt = MIDI_mciFindNextEvent(wmm, &hiPulse)) == NULL)
 973             break;  /* no more event on tracks */
 974
 975         /* if starting playing, then set StartTicks to the value it would have had
 976          * if play had started at position 0
 977          */
 978         if (doPlay && !wmm->wStartedPlaying) {
 979             wmm->dwStartTicks = GetTickCount() - MIDI_ConvertPulseToMS(wmm, wmm->dwPulse);
 980             wmm->wStartedPlaying = TRUE;
 981             TRACE("Setting dwStartTicks to %lu\n", wmm->dwStartTicks);
 982         }
 983
 984         if (hiPulse > wmm->dwPulse) {
 985             wmm->dwPositionMS += MIDI_ConvertPulseToMS(wmm, hiPulse - wmm->dwPulse);
 986             if (doPlay) {
 987                 DWORD   togo = wmm->dwStartTicks + wmm->dwPositionMS;
 988                 DWORD   tc = GetTickCount();
 989
 990                 TRACE("Pulses hi=0x%08lx <> cur=0x%08lx\n", hiPulse, wmm->dwPulse);
 991                 TRACE("Wait until %lu => %lu ms\n",
 992                       tc - wmm->dwStartTicks, togo - wmm->dwStartTicks);
 993                 if (tc < togo)
 994                     Sleep(togo - tc);
 995             }
 996             wmm->dwPulse = hiPulse;
 997         }
 998
 999         switch (LOBYTE(LOWORD(mmt->dwEventData))) {
1000         case 0xF0:
1001         case 0xF7:      /* sysex events */
1002             {
1003                 FIXME("Not handling SysEx events (yet)\n");
1004             }
1005             break;
1006         case 0xFF:
1007             /* position after meta data header */
1008             mmioSeek(wmm->hFile, mmt->dwIndex + HIWORD(mmt->dwEventData), SEEK_SET);
1009             switch (HIBYTE(LOWORD(mmt->dwEventData))) {
1010             case 0x00: /* 16-bit sequence number */
1011                 if (TRACE_ON(mcimidi)) {
1012                     WORD        twd;
1013
1014                     MIDI_mciReadWord(wmm, &twd);        /* == 0 */
1015                     TRACE("Got sequence number %u\n", twd);
1016                 }
1017                 break;
1018             case 0x01: /* any text */
1019             case 0x02: /* Copyright Message text */
1020             case 0x03: /* Sequence/Track Name text */
1021             case 0x04: /* Instrument Name text */
1022             case 0x05: /* Lyric text */
1023             case 0x06: /* Marker text */
1024             case 0x07: /* Cue-point text */
1025                 if (TRACE_ON(mcimidi)) {
1026                     char        buf[1024];
1027                     WORD        len = mmt->wEventLength - HIWORD(mmt->dwEventData);
1028                     static      char*   info[8] = {"", "Text", "Copyright", "Seq/Trk name",
1029                                                    "Instrument", "Lyric", "Marker", "Cue-point"};
1030                     WORD        idx = HIBYTE(LOWORD(mmt->dwEventData));
1031
1032                     if (len >= sizeof(buf)) {
1033                         WARN("Buffer for text is too small (%d bytes, when %u are needed)\n", sizeof(buf) - 1, len);
1034                         len = sizeof(buf) - 1;
1035                     }
1036                     if (mmioRead(wmm->hFile, (HPSTR)buf, len) == len) {
1037                         buf[len] = 0;   /* end string in case */
1038                         TRACE("%s => \"%s\"\n", (idx < 8 ) ? info[idx] : "", buf);
1039                     } else {
1040                         WARN("Couldn't read data for %s\n", (idx < 8) ? info[idx] : "");
1041                     }
1042                 }
1043                 break;
1044             case 0x20:
1045                 /* MIDI channel (cc) */
1046                 if (FIXME_ON(mcimidi)) {
1047                     BYTE        bt;
1048
1049                     MIDI_mciReadByte(wmm, &bt); /* == 0 */
1050                     FIXME("NIY: MIDI channel=%u, track=%u\n", bt, mmt->wTrackNr);
1051                 }
1052                 break;
1053             case 0x21:
1054                 /* MIDI port (pp) */
1055                 if (FIXME_ON(mcimidi)) {
1056                     BYTE        bt;
1057
1058                     MIDI_mciReadByte(wmm, &bt); /* == 0 */
1059                     FIXME("NIY: MIDI port=%u, track=%u\n", bt, mmt->wTrackNr);
1060                 }
1061                 break;
1062             case 0x2F: /* end of track */
1063                 mmt->wStatus = 0;
1064                 break;
1065             case 0x51:/* set tempo */
1066                 /* Tempo is expressed in µ-seconds per midi quarter note
1067                  * for format 1 MIDI files, this can only be present on track #0
1068                  */
1069                 if (mmt->wTrackNr != 0 && wmm->wFormat == 1) {
1070                     WARN("For format #1 MIDI files, tempo can only be changed on track #0 (%u)\n", mmt->wTrackNr);
1071                 } else {
1072                     BYTE        tbt;
1073                     DWORD       value = 0;
1074
1075                     MIDI_mciReadByte(wmm, &tbt);        value  = ((DWORD)tbt) << 16;
1076                     MIDI_mciReadByte(wmm, &tbt);        value |= ((DWORD)tbt) << 8;
1077                     MIDI_mciReadByte(wmm, &tbt);        value |= ((DWORD)tbt) << 0;
1078                     TRACE("Setting tempo to %ld (BPM=%ld)\n", wmm->dwTempo, (value) ? (60000000l / value) : 0);
1079                     wmm->dwTempo = value;
1080                 }
1081                 break;
1082             case 0x54: /* (hour) (min) (second) (frame) (fractional-frame) - SMPTE track start */
1083                 if (mmt->wTrackNr != 0 && wmm->wFormat == 1) {
1084                     WARN("For format #1 MIDI files, SMPTE track start can only be expressed on track #0 (%u)\n", mmt->wTrackNr);
1085                 } if (mmt->dwEventPulse != 0) {
1086                     WARN("SMPTE track start can only be expressed at start of track (%lu)\n", mmt->dwEventPulse);
1087                 } else {
1088                     BYTE        h, m, s, f, ff;
1089
1090                     MIDI_mciReadByte(wmm, &h);
1091                     MIDI_mciReadByte(wmm, &m);
1092                     MIDI_mciReadByte(wmm, &s);
1093                     MIDI_mciReadByte(wmm, &f);
1094                     MIDI_mciReadByte(wmm, &ff);
1095                     FIXME("NIY: SMPTE track start %u:%u:%u %u.%u\n", h, m, s, f, ff);
1096                 }
1097                 break;
1098             case 0x58: /* file rythm */
1099                 if (TRACE_ON(mcimidi)) {
1100                     BYTE        num, den, cpmc, _32npqn;
1101
1102                     MIDI_mciReadByte(wmm, &num);
1103                     MIDI_mciReadByte(wmm, &den);                /* to notate e.g. 6/8 */
1104                     MIDI_mciReadByte(wmm, &cpmc);               /* number of MIDI clocks per metronome click */
1105                     MIDI_mciReadByte(wmm, &_32npqn);            /* number of notated 32nd notes per MIDI quarter note */
1106
1107                     TRACE("%u/%u, clock per metronome click=%u, 32nd notes by 1/4 note=%u\n", num, 1 << den, cpmc, _32npqn);
1108                 }
1109                 break;
1110             case 0x59: /* key signature */
1111                 if (TRACE_ON(mcimidi)) {
1112                     BYTE        sf, mm;
1113
1114                     MIDI_mciReadByte(wmm, &sf);
1115                     MIDI_mciReadByte(wmm, &mm);
1116
1117                     if (sf >= 0x80)     TRACE("%d flats\n", -(char)sf);
1118                     else if (sf > 0)    TRACE("%d sharps\n", (char)sf);
1119                     else                TRACE("Key of C\n");
1120                     TRACE("Mode: %s\n", (mm = 0) ? "major" : "minor");
1121                 }
1122                 break;
1123             default:
1124                 WARN("Unknown MIDI meta event %02x. Skipping...\n", HIBYTE(LOWORD(mmt->dwEventData)));
1125                 break;
1126             }
1127             break;
1128         default:
1129             if (doPlay) {
1130                 dwRet = midiOutShortMsg(wmm->hMidi, mmt->dwEventData);
1131             } else {
1132                 switch (LOBYTE(LOWORD(mmt->dwEventData)) & 0xF0) {
1133                 case MIDI_NOTEON:
1134                 case MIDI_NOTEOFF:
1135                     dwRet = 0;
1136                     break;
1137                 default:
1138                     dwRet = midiOutShortMsg(wmm->hMidi, mmt->dwEventData);
1139                 }
1140             }
1141         }
1142         mmt->dwIndex += mmt->wEventLength;
1143         if (mmt->dwIndex < mmt->dwFirst || mmt->dwIndex >= mmt->dwLast) {
1144             mmt->wStatus = 0;
1145         }
1146         if (mmt->wStatus) {
1147             MIDI_mciReadNextEvent(wmm, mmt);
1148         }
1149     }
1150
1151     midiOutReset(wmm->hMidi);
1152
1153     dwRet = midiOutClose(wmm->hMidi);
1154     /* to restart playing at beginning when it's over */
1155     wmm->dwPositionMS = 0;
1156
1157     if (lpParms && (dwFlags & MCI_NOTIFY)) {
1158         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
1159         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1160                         wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1161     }
1162
1163     wmm->dwStatus = MCI_MODE_STOP;
1164     return dwRet;
1165 }
1166
1167 /**************************************************************************
1168  *                              MIDI_mciRecord                  [internal]
1169  */
1170 static DWORD MIDI_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms)
1171 {
1172     int                 start, end;
1173     MIDIHDR             midiHdr;
1174     DWORD               dwRet;
1175     WINE_MCIMIDI*       wmm = MIDI_mciGetOpenDev(wDevID);
1176
1177     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1178
1179     if (wmm == 0)       return MCIERR_INVALID_DEVICE_ID;
1180
1181     if (wmm->hFile == 0) {
1182         WARN("Can't find file='%s' !\n", wmm->lpstrElementName);
1183         return MCIERR_FILE_NOT_FOUND;
1184     }
1185     start = 1;          end = 99999;
1186     if (lpParms && (dwFlags & MCI_FROM)) {
1187         start = lpParms->dwFrom;
1188         TRACE("MCI_FROM=%d \n", start);
1189     }
1190     if (lpParms && (dwFlags & MCI_TO)) {
1191         end = lpParms->dwTo;
1192         TRACE("MCI_TO=%d \n", end);
1193     }
1194     midiHdr.lpData = (LPSTR) HeapAlloc(GetProcessHeap(), 0, 1200);
1195     if (!midiHdr.lpData)
1196         return MCIERR_OUT_OF_MEMORY;
1197     midiHdr.dwBufferLength = 1024;
1198     midiHdr.dwUser = 0L;
1199     midiHdr.dwFlags = 0L;
1200     dwRet = midiInPrepareHeader(wmm->hMidi, &midiHdr, sizeof(MIDIHDR));
1201     TRACE("After MIDM_PREPARE \n");
1202     wmm->dwStatus = MCI_MODE_RECORD;
1203     /* FIXME: there is no buffer added */
1204     while (wmm->dwStatus != MCI_MODE_STOP) {
1205         TRACE("wmm->dwStatus=%p %d\n",
1206               &wmm->dwStatus, wmm->dwStatus);
1207         midiHdr.dwBytesRecorded = 0;
1208         dwRet = midiInStart(wmm->hMidi);
1209         TRACE("midiInStart => dwBytesRecorded=%lu\n", midiHdr.dwBytesRecorded);
1210         if (midiHdr.dwBytesRecorded == 0) break;
1211     }
1212     TRACE("Before MIDM_UNPREPARE \n");
1213     dwRet = midiInUnprepareHeader(wmm->hMidi, &midiHdr, sizeof(MIDIHDR));
1214     TRACE("After MIDM_UNPREPARE \n");
1215     if (midiHdr.lpData != NULL) {
1216         HeapFree(GetProcessHeap(), 0, midiHdr.lpData);
1217         midiHdr.lpData = NULL;
1218     }
1219     wmm->dwStatus = MCI_MODE_STOP;
1220     if (lpParms && (dwFlags & MCI_NOTIFY)) {
1221         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
1222         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1223                         wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1224     }
1225     return 0;
1226 }
1227
1228 /**************************************************************************
1229  *                              MIDI_mciPause                   [internal]
1230  */
1231 static DWORD MIDI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
1232 {
1233     WINE_MCIMIDI*       wmm = MIDI_mciGetOpenDev(wDevID);
1234
1235     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1236
1237     if (wmm == NULL)    return MCIERR_INVALID_DEVICE_ID;
1238
1239     if (wmm->dwStatus == MCI_MODE_PLAY) {
1240         /* stop all notes */
1241         unsigned chn;
1242         for (chn = 0; chn < 16; chn++)
1243             midiOutShortMsg(wmm->hMidi, 0x78B0 | chn);
1244         wmm->dwStatus = MCI_MODE_PAUSE;
1245     }
1246     if (lpParms && (dwFlags & MCI_NOTIFY)) {
1247         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
1248         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1249                         wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1250     }
1251
1252     return 0;
1253 }
1254
1255 /**************************************************************************
1256  *                              MIDI_mciResume                  [internal]
1257  */
1258 static DWORD MIDI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
1259 {
1260     WINE_MCIMIDI*       wmm = MIDI_mciGetOpenDev(wDevID);
1261
1262     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1263
1264     if (wmm == NULL)    return MCIERR_INVALID_DEVICE_ID;
1265
1266     if (wmm->dwStatus == MCI_MODE_PAUSE) {
1267         wmm->wStartedPlaying = FALSE;
1268         wmm->dwStatus = MCI_MODE_PLAY;
1269     }
1270     if (lpParms && (dwFlags & MCI_NOTIFY)) {
1271         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
1272         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1273                         wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1274     }
1275     return 0;
1276 }
1277
1278 /**************************************************************************
1279  *                              MIDI_mciSet                     [internal]
1280  */
1281 static DWORD MIDI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
1282 {
1283     WINE_MCIMIDI*       wmm = MIDI_mciGetOpenDev(wDevID);
1284
1285     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1286
1287     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1288     if (wmm == NULL)            return MCIERR_INVALID_DEVICE_ID;
1289
1290     if (dwFlags & MCI_SET_TIME_FORMAT) {
1291         switch (lpParms->dwTimeFormat) {
1292         case MCI_FORMAT_MILLISECONDS:
1293             TRACE("MCI_FORMAT_MILLISECONDS !\n");
1294             wmm->dwMciTimeFormat = MCI_FORMAT_MILLISECONDS;
1295             break;
1296         case MCI_FORMAT_SMPTE_24:
1297             TRACE("MCI_FORMAT_SMPTE_24 !\n");
1298             wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_24;
1299             break;
1300         case MCI_FORMAT_SMPTE_25:
1301             TRACE("MCI_FORMAT_SMPTE_25 !\n");
1302             wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_25;
1303             break;
1304         case MCI_FORMAT_SMPTE_30:
1305             TRACE("MCI_FORMAT_SMPTE_30 !\n");
1306             wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_30;
1307             break;
1308         default:
1309             WARN("Bad time format %lu!\n", lpParms->dwTimeFormat);
1310             return MCIERR_BAD_TIME_FORMAT;
1311         }
1312     }
1313     if (dwFlags & MCI_SET_VIDEO) {
1314         TRACE("No support for video !\n");
1315         return MCIERR_UNSUPPORTED_FUNCTION;
1316     }
1317     if (dwFlags & MCI_SET_DOOR_OPEN) {
1318         TRACE("No support for door open !\n");
1319         return MCIERR_UNSUPPORTED_FUNCTION;
1320     }
1321     if (dwFlags & MCI_SET_DOOR_CLOSED) {
1322         TRACE("No support for door close !\n");
1323         return MCIERR_UNSUPPORTED_FUNCTION;
1324     }
1325     if (dwFlags & MCI_SET_AUDIO) {
1326         if (dwFlags & MCI_SET_ON) {
1327             TRACE("MCI_SET_ON audio !\n");
1328         } else if (dwFlags & MCI_SET_OFF) {
1329             TRACE("MCI_SET_OFF audio !\n");
1330         } else {
1331             WARN("MCI_SET_AUDIO without SET_ON or SET_OFF\n");
1332             return MCIERR_BAD_INTEGER;
1333         }
1334
1335         if (lpParms->dwAudio & MCI_SET_AUDIO_ALL)
1336             TRACE("MCI_SET_AUDIO_ALL !\n");
1337         if (lpParms->dwAudio & MCI_SET_AUDIO_LEFT)
1338             TRACE("MCI_SET_AUDIO_LEFT !\n");
1339         if (lpParms->dwAudio & MCI_SET_AUDIO_RIGHT)
1340             TRACE("MCI_SET_AUDIO_RIGHT !\n");
1341     }
1342
1343     if (dwFlags & MCI_SEQ_SET_MASTER)
1344         TRACE("MCI_SEQ_SET_MASTER !\n");
1345     if (dwFlags & MCI_SEQ_SET_SLAVE)
1346         TRACE("MCI_SEQ_SET_SLAVE !\n");
1347     if (dwFlags & MCI_SEQ_SET_OFFSET)
1348         TRACE("MCI_SEQ_SET_OFFSET !\n");
1349     if (dwFlags & MCI_SEQ_SET_PORT)
1350         TRACE("MCI_SEQ_SET_PORT !\n");
1351     if (dwFlags & MCI_SEQ_SET_TEMPO)
1352         TRACE("MCI_SEQ_SET_TEMPO !\n");
1353     return 0;
1354 }
1355
1356 /**************************************************************************
1357  *                              MIDI_mciStatus                  [internal]
1358  */
1359 static DWORD MIDI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
1360 {
1361     WINE_MCIMIDI*       wmm = MIDI_mciGetOpenDev(wDevID);
1362     DWORD               ret = 0;
1363
1364     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1365
1366     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1367     if (wmm == NULL)            return MCIERR_INVALID_DEVICE_ID;
1368
1369     if (dwFlags & MCI_STATUS_ITEM) {
1370         switch (lpParms->dwItem) {
1371         case MCI_STATUS_CURRENT_TRACK:
1372             /* FIXME in Format 2 */
1373             lpParms->dwReturn = 1;
1374             TRACE("MCI_STATUS_CURRENT_TRACK => %lu\n", lpParms->dwReturn);
1375             break;
1376         case MCI_STATUS_LENGTH:
1377             if ((dwFlags & MCI_TRACK) && wmm->wFormat == 2) {
1378                 if (lpParms->dwTrack >= wmm->nTracks)
1379                     return MCIERR_BAD_INTEGER;
1380                 /* FIXME: this is wrong if there is a tempo change inside the file */
1381                 lpParms->dwReturn = MIDI_ConvertPulseToMS(wmm, wmm->tracks[lpParms->dwTrack].dwLength);
1382             } else {
1383                 lpParms->dwReturn = MIDI_GetMThdLengthMS(wmm);
1384             }
1385             lpParms->dwReturn = MIDI_ConvertMSToTimeFormat(wmm, lpParms->dwReturn);
1386             TRACE("MCI_STATUS_LENGTH => %lu\n", lpParms->dwReturn);
1387             break;
1388         case MCI_STATUS_MODE:
1389             TRACE("MCI_STATUS_MODE => %u\n", wmm->dwStatus);
1390             lpParms->dwReturn = MAKEMCIRESOURCE(wmm->dwStatus, wmm->dwStatus);
1391             ret = MCI_RESOURCE_RETURNED;
1392             break;
1393         case MCI_STATUS_MEDIA_PRESENT:
1394             TRACE("MCI_STATUS_MEDIA_PRESENT => TRUE\n");
1395             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1396             ret = MCI_RESOURCE_RETURNED;
1397             break;
1398         case MCI_STATUS_NUMBER_OF_TRACKS:
1399             lpParms->dwReturn = (wmm->wFormat == 2) ? wmm->nTracks : 1;
1400             TRACE("MCI_STATUS_NUMBER_OF_TRACKS => %lu\n", lpParms->dwReturn);
1401             break;
1402         case MCI_STATUS_POSITION:
1403             /* FIXME: do I need to use MCI_TRACK ? */
1404             lpParms->dwReturn = MIDI_ConvertMSToTimeFormat(wmm,
1405                                                            (dwFlags & MCI_STATUS_START) ? 0 : wmm->dwPositionMS);
1406             TRACE("MCI_STATUS_POSITION %s => %lu\n",
1407                   (dwFlags & MCI_STATUS_START) ? "start" : "current", lpParms->dwReturn);
1408             break;
1409         case MCI_STATUS_READY:
1410             lpParms->dwReturn = (wmm->dwStatus == MCI_MODE_NOT_READY) ?
1411                 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1412             ret = MCI_RESOURCE_RETURNED;
1413             TRACE("MCI_STATUS_READY = %u\n", LOWORD(lpParms->dwReturn));
1414             break;
1415         case MCI_STATUS_TIME_FORMAT:
1416             lpParms->dwReturn = MAKEMCIRESOURCE(wmm->dwMciTimeFormat, wmm->dwMciTimeFormat);
1417             TRACE("MCI_STATUS_TIME_FORMAT => %u\n", LOWORD(lpParms->dwReturn));
1418             ret = MCI_RESOURCE_RETURNED;
1419             break;
1420         case MCI_SEQ_STATUS_DIVTYPE:
1421             TRACE("MCI_SEQ_STATUS_DIVTYPE !\n");
1422             if (wmm->nDivision > 0x8000) {
1423                 switch (wmm->nDivision) {
1424                 case 0xE8:      lpParms->dwReturn = MCI_SEQ_DIV_SMPTE_24;       break;  /* -24 */
1425                 case 0xE7:      lpParms->dwReturn = MCI_SEQ_DIV_SMPTE_25;       break;  /* -25 */
1426                 case 0xE3:      lpParms->dwReturn = MCI_SEQ_DIV_SMPTE_30DROP;   break;  /* -29 */ /* is the MCI constant correct ? */
1427                 case 0xE2:      lpParms->dwReturn = MCI_SEQ_DIV_SMPTE_30;       break;  /* -30 */
1428                 default:        FIXME("There is a bad bad programmer\n");
1429                 }
1430             } else {
1431                 lpParms->dwReturn = MCI_SEQ_DIV_PPQN;
1432             }
1433             lpParms->dwReturn = MAKEMCIRESOURCE(lpParms->dwReturn,lpParms->dwReturn);
1434             ret = MCI_RESOURCE_RETURNED;
1435             break;
1436         case MCI_SEQ_STATUS_MASTER:
1437             TRACE("MCI_SEQ_STATUS_MASTER !\n");
1438             lpParms->dwReturn = 0;
1439             break;
1440         case MCI_SEQ_STATUS_SLAVE:
1441             TRACE("MCI_SEQ_STATUS_SLAVE !\n");
1442             lpParms->dwReturn = 0;
1443             break;
1444         case MCI_SEQ_STATUS_OFFSET:
1445             TRACE("MCI_SEQ_STATUS_OFFSET !\n");
1446             lpParms->dwReturn = 0;
1447             break;
1448         case MCI_SEQ_STATUS_PORT:
1449             TRACE("MCI_SEQ_STATUS_PORT (%u)!\n", wmm->wDevID);
1450             lpParms->dwReturn = MIDI_MAPPER;
1451             break;
1452         case MCI_SEQ_STATUS_TEMPO:
1453             TRACE("MCI_SEQ_STATUS_TEMPO !\n");
1454             lpParms->dwReturn = wmm->dwTempo;
1455             break;
1456         default:
1457             FIXME("Unknowm command %08lX !\n", lpParms->dwItem);
1458             return MCIERR_UNRECOGNIZED_COMMAND;
1459         }
1460     } else {
1461         WARN("No Status-Item!\n");
1462         return MCIERR_UNRECOGNIZED_COMMAND;
1463     }
1464     if (dwFlags & MCI_NOTIFY) {
1465         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
1466         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1467                         wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1468     }
1469     return ret;
1470 }
1471
1472 /**************************************************************************
1473  *                              MIDI_mciGetDevCaps              [internal]
1474  */
1475 static DWORD MIDI_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
1476                                 LPMCI_GETDEVCAPS_PARMS lpParms)
1477 {
1478     WINE_MCIMIDI*       wmm = MIDI_mciGetOpenDev(wDevID);
1479     DWORD               ret;
1480
1481     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1482
1483     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1484     if (wmm == NULL)            return MCIERR_INVALID_DEVICE_ID;
1485
1486     if (dwFlags & MCI_GETDEVCAPS_ITEM) {
1487         switch (lpParms->dwItem) {
1488         case MCI_GETDEVCAPS_DEVICE_TYPE:
1489             TRACE("MCI_GETDEVCAPS_DEVICE_TYPE !\n");
1490             lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_SEQUENCER, MCI_DEVTYPE_SEQUENCER);
1491             ret = MCI_RESOURCE_RETURNED;
1492             break;
1493         case MCI_GETDEVCAPS_HAS_AUDIO:
1494             TRACE("MCI_GETDEVCAPS_HAS_AUDIO !\n");
1495             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1496             ret = MCI_RESOURCE_RETURNED;
1497             break;
1498         case MCI_GETDEVCAPS_HAS_VIDEO:
1499             TRACE("MCI_GETDEVCAPS_HAS_VIDEO !\n");
1500             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
1501             ret = MCI_RESOURCE_RETURNED;
1502             break;
1503         case MCI_GETDEVCAPS_USES_FILES:
1504             TRACE("MCI_GETDEVCAPS_USES_FILES !\n");
1505             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1506             ret = MCI_RESOURCE_RETURNED;
1507             break;
1508         case MCI_GETDEVCAPS_COMPOUND_DEVICE:
1509             TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE !\n");
1510             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1511             ret = MCI_RESOURCE_RETURNED;
1512             break;
1513         case MCI_GETDEVCAPS_CAN_EJECT:
1514             TRACE("MCI_GETDEVCAPS_CAN_EJECT !\n");
1515             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
1516             ret = MCI_RESOURCE_RETURNED;
1517             break;
1518         case MCI_GETDEVCAPS_CAN_PLAY:
1519             TRACE("MCI_GETDEVCAPS_CAN_PLAY !\n");
1520             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1521             ret = MCI_RESOURCE_RETURNED;
1522             break;
1523         case MCI_GETDEVCAPS_CAN_RECORD:
1524             TRACE("MCI_GETDEVCAPS_CAN_RECORD !\n");
1525             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1526             ret = MCI_RESOURCE_RETURNED;
1527             break;
1528         case MCI_GETDEVCAPS_CAN_SAVE:
1529             TRACE("MCI_GETDEVCAPS_CAN_SAVE !\n");
1530             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
1531             ret = MCI_RESOURCE_RETURNED;
1532             break;
1533         default:
1534             FIXME("Unknown capability (%08lx) !\n", lpParms->dwItem);
1535             return MCIERR_UNRECOGNIZED_COMMAND;
1536         }
1537     } else {
1538         WARN("No GetDevCaps-Item !\n");
1539         return MCIERR_UNRECOGNIZED_COMMAND;
1540     }
1541     return ret;
1542 }
1543
1544 /**************************************************************************
1545  *                              MIDI_mciInfo                    [internal]
1546  */
1547 static DWORD MIDI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSA lpParms)
1548 {
1549     LPCSTR              str = 0;
1550     WINE_MCIMIDI*       wmm = MIDI_mciGetOpenDev(wDevID);
1551     DWORD               ret = 0;
1552
1553     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1554
1555     if (lpParms == NULL || lpParms->lpstrReturn == NULL)
1556         return MCIERR_NULL_PARAMETER_BLOCK;
1557     if (wmm == NULL) return MCIERR_INVALID_DEVICE_ID;
1558
1559     TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
1560
1561     switch (dwFlags & ~(MCI_WAIT|MCI_NOTIFY)) {
1562     case MCI_INFO_PRODUCT:
1563         str = "Wine's MIDI sequencer";
1564         break;
1565     case MCI_INFO_FILE:
1566         str = wmm->lpstrElementName;
1567         break;
1568     case MCI_INFO_COPYRIGHT:
1569         str = wmm->lpstrCopyright;
1570         break;
1571     case MCI_INFO_NAME:
1572         str = wmm->lpstrName;
1573         break;
1574     default:
1575         WARN("Don't know this info command (%lu)\n", dwFlags);
1576         return MCIERR_UNRECOGNIZED_COMMAND;
1577     }
1578     if (str) {
1579         if (lpParms->dwRetSize <= strlen(str)) {
1580             lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize - 1);
1581             ret = MCIERR_PARAM_OVERFLOW;
1582         } else {
1583             strcpy(lpParms->lpstrReturn, str);
1584         }
1585     } else {
1586         *lpParms->lpstrReturn = 0;
1587     }
1588     return ret;
1589 }
1590
1591 /**************************************************************************
1592  *                              MIDI_mciSeek                    [internal]
1593  */
1594 static DWORD MIDI_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
1595 {
1596     DWORD               ret = 0;
1597     WINE_MCIMIDI*       wmm = MIDI_mciGetOpenDev(wDevID);
1598
1599     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1600
1601     if (lpParms == NULL) {
1602         ret = MCIERR_NULL_PARAMETER_BLOCK;
1603     } else if (wmm == NULL) {
1604         ret = MCIERR_INVALID_DEVICE_ID;
1605     } else {
1606         MIDI_mciStop(wDevID, MCI_WAIT, 0);
1607
1608         if (dwFlags & MCI_SEEK_TO_START) {
1609             wmm->dwPositionMS = 0;
1610         } else if (dwFlags & MCI_SEEK_TO_END) {
1611             wmm->dwPositionMS = 0xFFFFFFFF; /* fixme */
1612         } else if (dwFlags & MCI_TO) {
1613             wmm->dwPositionMS = MIDI_ConvertTimeFormatToMS(wmm, lpParms->dwTo);
1614         } else {
1615             WARN("dwFlag doesn't tell where to seek to...\n");
1616             return MCIERR_MISSING_PARAMETER;
1617         }
1618
1619         TRACE("Seeking to position=%lu ms\n", wmm->dwPositionMS);
1620
1621         if (dwFlags & MCI_NOTIFY) {
1622             TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
1623             mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1624                             wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1625         }
1626     }
1627     return ret;
1628 }
1629
1630 /*======================================================================*
1631  *                          MIDI entry points                           *
1632  *======================================================================*/
1633
1634 /**************************************************************************
1635  *                              MCIMIDI_DriverProc           [sample driver]
1636  */
1637 LONG CALLBACK   MCIMIDI_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
1638                                    DWORD dwParam1, DWORD dwParam2)
1639 {
1640     switch (wMsg) {
1641     case DRV_LOAD:              return 1;
1642     case DRV_FREE:              return 1;
1643     case DRV_ENABLE:            return 1;
1644     case DRV_DISABLE:           return 1;
1645     case DRV_QUERYCONFIGURE:    return 1;
1646     case DRV_CONFIGURE:         MessageBoxA(0, "Sample Midi Driver !", "OSS Driver", MB_OK); return 1;
1647     case DRV_INSTALL:           return DRVCNF_RESTART;
1648     case DRV_REMOVE:            return DRVCNF_RESTART;
1649     case DRV_OPEN:              return MIDI_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
1650     case DRV_CLOSE:             return MIDI_drvClose(dwDevID);
1651     case MCI_OPEN_DRIVER:       return MIDI_mciOpen      (dwDevID, dwParam1, (LPMCI_OPEN_PARMSA)     dwParam2);
1652     case MCI_CLOSE_DRIVER:      return MIDI_mciClose     (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)   dwParam2);
1653     case MCI_PLAY:              return MIDI_mciPlay      (dwDevID, dwParam1, (LPMCI_PLAY_PARMS)      dwParam2);
1654     case MCI_RECORD:            return MIDI_mciRecord    (dwDevID, dwParam1, (LPMCI_RECORD_PARMS)    dwParam2);
1655     case MCI_STOP:              return MIDI_mciStop      (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)   dwParam2);
1656     case MCI_SET:               return MIDI_mciSet       (dwDevID, dwParam1, (LPMCI_SET_PARMS)       dwParam2);
1657     case MCI_PAUSE:             return MIDI_mciPause     (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)   dwParam2);
1658     case MCI_RESUME:            return MIDI_mciResume    (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)   dwParam2);
1659     case MCI_STATUS:            return MIDI_mciStatus    (dwDevID, dwParam1, (LPMCI_STATUS_PARMS)    dwParam2);
1660     case MCI_GETDEVCAPS:        return MIDI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
1661     case MCI_INFO:              return MIDI_mciInfo      (dwDevID, dwParam1, (LPMCI_INFO_PARMSA)     dwParam2);
1662     case MCI_SEEK:              return MIDI_mciSeek      (dwDevID, dwParam1, (LPMCI_SEEK_PARMS)      dwParam2);
1663     /* commands that should be supported */
1664     case MCI_LOAD:
1665     case MCI_SAVE:
1666     case MCI_FREEZE:
1667     case MCI_PUT:
1668     case MCI_REALIZE:
1669     case MCI_UNFREEZE:
1670     case MCI_UPDATE:
1671     case MCI_WHERE:
1672     case MCI_STEP:
1673     case MCI_SPIN:
1674     case MCI_ESCAPE:
1675     case MCI_COPY:
1676     case MCI_CUT:
1677     case MCI_DELETE:
1678     case MCI_PASTE:
1679         WARN("Unsupported command [%lu]\n", wMsg);
1680         break;
1681     /* commands that should report an error */
1682     case MCI_WINDOW:
1683         TRACE("Unsupported command [%lu]\n", wMsg);
1684         break;
1685     case MCI_OPEN:
1686     case MCI_CLOSE:
1687         FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1688         break;
1689     default:
1690         TRACE("Sending msg [%lu] to default driver proc\n", wMsg);
1691         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1692     }
1693     return MCIERR_UNRECOGNIZED_COMMAND;
1694 }
1695
1696