misc/midi.c

   1 /*
   2  * Sample MIDI 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 #define DEBUG_MCIMIDI
  15
  16 #include "stdio.h"
  17 #include "win.h"
  18 #include "user.h"
  19 #include "driver.h"
  20 #include "mmsystem.h"
  21
  22 #include <fcntl.h>
  23 #include <sys/ioctl.h>
  24 #ifdef linux
  25 #include <linux/soundcard.h>
  26 #endif
  27
  28 #ifdef linux
  29 #define MIDI_DEV "/dev/midi"
  30
  31 #ifdef SOUND_VERSION
  32 #define IOCTL(a,b,c)            ioctl(a,b,&c)
  33 #else
  34 #define IOCTL(a,b,c)            (c = ioctl(a,b,c) )
  35 #endif
  36
  37 #define MAX_MIDIINDRV   2
  38 #define MAX_MIDIOUTDRV  2
  39 #define MAX_MCIMIDIDRV  2
  40
  41 typedef struct {
  42         int                             unixdev;
  43         int                             state;
  44         DWORD                   bufsize;
  45         MIDIOPENDESC    midiDesc;
  46         WORD                    wFlags;
  47         MIDIHDR                 lpQueueHdr;
  48         DWORD                   dwTotalPlayed;
  49         } LINUX_MIDIIN;
  50
  51 typedef struct {
  52         int                             unixdev;
  53         int                             state;
  54         DWORD                   bufsize;
  55         MIDIOPENDESC    midiDesc;
  56         WORD                    wFlags;
  57         MIDIHDR                 lpQueueHdr;
  58         DWORD                   dwTotalPlayed;
  59         } LINUX_MIDIOUT;
  60
  61 typedef struct {
  62         int     nUseCount;          /* Incremented for each shared open */
  63         BOOL    fShareable;         /* TRUE if first open was shareable */
  64         WORD    wNotifyDeviceID;    /* MCI device ID with a pending notification */
  65         HANDLE  hCallback;          /* Callback handle for pending notification */
  66         HMMIO   hFile;                          /* mmio file handle open as Element             */
  67         MCI_OPEN_PARMS openParms;
  68         MIDIHDR         MidiHdr;
  69         WORD            dwStatus;
  70         } LINUX_MCIMIDI;
  71
  72 static LINUX_MIDIIN             MidiInDev[MAX_MIDIINDRV];
  73 static LINUX_MIDIOUT    MidiOutDev[MAX_MIDIOUTDRV];
  74 static LINUX_MCIMIDI    MCIMidiDev[MAX_MCIMIDIDRV];
  75 #endif
  76
  77 DWORD MIDI_mciOpen(DWORD dwFlags, LPMCI_OPEN_PARMS lpParms);
  78 DWORD MIDI_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms);
  79 DWORD MIDI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms);
  80 DWORD MIDI_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms);
  81 DWORD MIDI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
  82 DWORD MIDI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
  83 DWORD MIDI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
  84 DWORD MIDI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms);
  85 DWORD MIDI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms);
  86 DWORD MIDI_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms);
  87 DWORD MIDI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms);
  88
  89
  90 /**************************************************************************
  91 *                               MIDI_NotifyClient                       [internal]
  92 */
  93 DWORD MIDI_NotifyClient(UINT wDevID, WORD wMsg,
  94                                 DWORD dwParam1, DWORD dwParam2)
  95 {
  96 #ifdef linux
  97         if (MidiInDev[wDevID].wFlags != DCB_NULL && !DriverCallback(
  98                 MidiInDev[wDevID].midiDesc.dwCallback, MidiInDev[wDevID].wFlags,
  99                 MidiInDev[wDevID].midiDesc.hMidi, wMsg,
 100                 MidiInDev[wDevID].midiDesc.dwInstance, dwParam1, dwParam2)) {
 101                 printf("MIDI_NotifyClient // can't notify client !\n");
 102                 return MMSYSERR_NOERROR;
 103                 }
 104 #else
 105         return MMSYSERR_NOTENABLED;
 106 #endif
 107 }
 108
 109
 110 /**************************************************************************
 111 *                               AUDIO_DriverProc                [sample driver]
 112 */
 113 LRESULT MIDI_DriverProc(DWORD dwDevID, HDRVR hDriv, WORD wMsg,
 114                                                 DWORD dwParam1, DWORD dwParam2)
 115 {
 116 #ifdef linux
 117         switch(wMsg) {
 118                 case DRV_LOAD:
 119                         return (LRESULT)1L;
 120                 case DRV_FREE:
 121                         return (LRESULT)1L;
 122                 case DRV_OPEN:
 123                         return (LRESULT)1L;
 124                 case DRV_CLOSE:
 125                         return (LRESULT)1L;
 126                 case DRV_ENABLE:
 127                         return (LRESULT)1L;
 128                 case DRV_DISABLE:
 129                         return (LRESULT)1L;
 130                 case DRV_QUERYCONFIGURE:
 131                         return (LRESULT)1L;
 132                 case DRV_CONFIGURE:
 133                         MessageBox((HWND)NULL, "Sample Midi Linux Driver !",
 134                                                                 "MMLinux Driver", MB_OK);
 135                         return (LRESULT)1L;
 136                 case DRV_INSTALL:
 137                         return (LRESULT)DRVCNF_RESTART;
 138                 case DRV_REMOVE:
 139                         return (LRESULT)DRVCNF_RESTART;
 140                 case MCI_OPEN_DRIVER:
 141                 case MCI_OPEN:
 142                         return MIDI_mciOpen(dwParam1, (LPMCI_OPEN_PARMS)dwParam2);
 143                 case MCI_CLOSE_DRIVER:
 144                 case MCI_CLOSE:
 145                         return MIDI_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
 146                 case MCI_PLAY:
 147                         return MIDI_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
 148                 case MCI_RECORD:
 149                         return MIDI_mciRecord(dwDevID, dwParam1, (LPMCI_RECORD_PARMS)dwParam2);
 150                 case MCI_STOP:
 151                         return MIDI_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
 152                 case MCI_SET:
 153                         return MIDI_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
 154                 case MCI_PAUSE:
 155                         return MIDI_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
 156                 case MCI_RESUME:
 157                         return MIDI_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
 158                 case MCI_STATUS:
 159                         return MIDI_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
 160                 case MCI_GETDEVCAPS:
 161                         return MIDI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
 162                 case MCI_INFO:
 163                         return MIDI_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS)dwParam2);
 164                 default:
 165                         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 166                 }
 167 #else
 168         return MMSYSERR_NOTENABLED;
 169 #endif
 170 }
 171
 172 /**************************************************************************
 173 *                               MIDI_mciOpen                    [internal]
 174 */
 175 DWORD MIDI_mciOpen(DWORD dwFlags, LPMCI_OPEN_PARMS lpParms)
 176 {
 177 #ifdef linux
 178         int                     hFile;
 179         UINT            wDevID;
 180         OFSTRUCT        OFstruct;
 181         MIDIOPENDESC    MidiDesc;
 182         DWORD           dwRet;
 183         char            str[128];
 184         LPSTR           ptr;
 185 #ifdef DEBUG_MCIMIDI
 186         printf("MIDI_mciOpen(%08X, %08X)\n", dwFlags, lpParms);
 187 #endif
 188         if (lpParms == NULL) return MCIERR_INTERNAL;
 189         wDevID = lpParms->wDeviceID;
 190         if (MCIMidiDev[wDevID].nUseCount > 0) {
 191                 /* The driver already open on this channel */
 192                 /* If the driver was opened shareable before and this open specifies */
 193                 /* shareable then increment the use count */
 194                 if (MCIMidiDev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
 195                         ++MCIMidiDev[wDevID].nUseCount;
 196                 else
 197                         return MCIERR_MUST_USE_SHAREABLE;
 198                 }
 199         else {
 200                 MCIMidiDev[wDevID].nUseCount = 1;
 201                 MCIMidiDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE;
 202                 }
 203     if (dwFlags & MCI_OPEN_ELEMENT) {
 204                 printf("MIDI_mciOpen // MCI_OPEN_ELEMENT '%s' !\n",
 205                                                                 lpParms->lpstrElementName);
 206 /*              printf("MIDI_mciOpen // cdw='%s'\n", DOS_GetCurrentDir(DOS_GetDefaultDrive())); */
 207                 if (strlen(lpParms->lpstrElementName) > 0) {
 208                         strcpy(str, lpParms->lpstrElementName);
 209                         AnsiUpper(str);
 210                         MCIMidiDev[wDevID].hFile = mmioOpen(str, NULL,
 211                                 MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_EXCLUSIVE);
 212                         if (MCIMidiDev[wDevID].hFile == 0) {
 213                                 printf("MIDI_mciOpen // can't find file='%s' !\n", str);
 214                                 return MCIERR_FILE_NOT_FOUND;
 215                                 }
 216                         }
 217                 else
 218                         MCIMidiDev[wDevID].hFile = 0;
 219                 }
 220         printf("MIDI_mciOpen // hFile=%u\n", MCIMidiDev[wDevID].hFile);
 221         memcpy(&MCIMidiDev[wDevID].openParms, lpParms, sizeof(MCI_OPEN_PARMS));
 222         MCIMidiDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID;
 223         MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
 224         MidiDesc.hMidi = 0;
 225         if (MCIMidiDev[wDevID].hFile != 0) {
 226                 MMCKINFO        mmckInfo;
 227                 MMCKINFO        ckMainRIFF;
 228                 if (mmioDescend(MCIMidiDev[wDevID].hFile, &ckMainRIFF, NULL, 0) != 0) {
 229                         return MCIERR_INTERNAL;
 230                         }
 231 #ifdef DEBUG_MCIMIDI
 232                 printf("MIDI_mciOpen // ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
 233                                 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType,
 234                                 ckMainRIFF.cksize);
 235 #endif
 236                 if (ckMainRIFF.ckid != FOURCC_RIFF) return MCIERR_INTERNAL;
 237                 if (ckMainRIFF.fccType != mmioFOURCC('R', 'M', 'I', 'D') &&
 238                         ckMainRIFF.fccType != mmioFOURCC('M', 'T', 'h', 'd')) {
 239                         return MCIERR_INTERNAL;
 240                         }
 241                 mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
 242                 if (mmioDescend(MCIMidiDev[wDevID].hFile, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) != 0) {
 243                         return MCIERR_INTERNAL;
 244                         }
 245 #ifdef DEBUG_MCIMIDI
 246                 printf("MIDI_mciOpen // Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
 247                                 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType,
 248                                 mmckInfo.cksize);
 249 #endif
 250                 }
 251         dwRet = modMessage(0, MODM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL);
 252         dwRet = midMessage(0, MIDM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL);
 253         return 0;
 254 #else
 255         return MMSYSERR_NOTENABLED;
 256 #endif
 257 }
 258
 259
 260 /**************************************************************************
 261 *                               MIDI_mciClose           [internal]
 262 */
 263 DWORD MIDI_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
 264 {
 265 #ifdef linux
 266         DWORD           dwRet;
 267 #ifdef DEBUG_MCIMIDI
 268         printf("MIDI_mciClose(%u, %08X, %08X);\n", wDevID, dwParam, lpParms);
 269 #endif
 270         if (MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) {
 271                 MIDI_mciStop(wDevID, MCI_WAIT, lpParms);
 272                 }
 273         MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
 274         MCIMidiDev[wDevID].nUseCount--;
 275         if (MCIMidiDev[wDevID].nUseCount == 0) {
 276                 if (MCIMidiDev[wDevID].hFile != 0) {
 277                         close(MCIMidiDev[wDevID].hFile);
 278                         MCIMidiDev[wDevID].hFile = 0;
 279                         }
 280                 dwRet = modMessage(0, MODM_CLOSE, 0, 0L, 0L);
 281                 if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
 282                 dwRet = midMessage(0, MIDM_CLOSE, 0, 0L, 0L);
 283                 if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
 284                 }
 285         return 0;
 286 #else
 287         return 0;
 288 #endif
 289 }
 290
 291
 292 /**************************************************************************
 293 *                               MIDI_mciPlay            [internal]
 294 */
 295 DWORD MIDI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
 296 {
 297 #ifdef linux
 298         int                     count;
 299         int                     start, end;
 300         LPMIDIHDR       lpMidiHdr;
 301         DWORD           dwRet;
 302 #ifdef DEBUG_MCIMIDI
 303         printf("MIDI_mciPlay(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
 304 #endif
 305         if (MCIMidiDev[wDevID].hFile == 0) {
 306                 printf("MIDI_mciPlay // can't find file='%s' !\n",
 307                                 MCIMidiDev[wDevID].openParms.lpstrElementName);
 308                 return MCIERR_FILE_NOT_FOUND;
 309                 }
 310         start = 1;              end = 99999;
 311         if (dwFlags & MCI_FROM) {
 312                 start = lpParms->dwFrom;
 313                 printf("MIDI_mciPlay // MCI_FROM=%d \n", start);
 314                 }
 315         if (dwFlags & MCI_TO) {
 316                 end = lpParms->dwTo;
 317                 printf("MIDI_mciPlay // MCI_TO=%d \n", end);
 318                 }
 319 /**/
 320         if (dwFlags & MCI_NOTIFY) {
 321                 printf("MIDI_mciPlay // MCI_NOTIFY %08X !\n", lpParms->dwCallback);
 322                 switch(fork()) {
 323                         case -1:
 324                                 printf("MIDI_mciPlay // Can't 'fork' process !\n");
 325                                 break;
 326                         case 0:
 327                                 printf("MIDI_mciPlay // process started ! play in background ...\n");
 328                                 break;
 329                         default:
 330                                 printf("MIDI_mciPlay // process started ! return to caller...\n");
 331                                 return 0;
 332                         }
 333                 }
 334 /**/
 335         lpMidiHdr = &MCIMidiDev[wDevID].MidiHdr;
 336         lpMidiHdr->lpData = (LPSTR) malloc(64000);
 337         lpMidiHdr->dwBufferLength = 32000;
 338         lpMidiHdr->dwUser = 0L;
 339         lpMidiHdr->dwFlags = 0L;
 340         dwRet = modMessage(0, MODM_PREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
 341 /*      printf("MIDI_mciPlay // after MODM_PREPARE \n"); */
 342         MCIMidiDev[wDevID].dwStatus = MCI_MODE_PLAY;
 343         while(MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) {
 344                 printf("MIDI_mciPlay // MCIMidiDev[wDevID].dwStatus=%p %d\n",
 345                         &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus);
 346                 count = mmioRead(MCIMidiDev[wDevID].hFile, lpMidiHdr->lpData, lpMidiHdr->dwBufferLength);
 347                 if (count < 1) break;
 348                 lpMidiHdr->dwBytesRecorded = count;
 349 #ifdef DEBUG_MCIMIDI
 350                 printf("MIDI_mciPlay // before MODM_LONGDATA lpMidiHdr=%08X dwBytesRecorded=%u\n",
 351                                         lpMidiHdr, lpMidiHdr->dwBytesRecorded);
 352 #endif
 353 /*              dwRet = modMessage(0, MODM_LONGDATA, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR)); */
 354                 }
 355         dwRet = modMessage(0, MODM_UNPREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
 356         if (lpMidiHdr->lpData != NULL) {
 357                 free(lpMidiHdr->lpData);
 358                 lpMidiHdr->lpData = NULL;
 359                 }
 360         MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
 361         if (dwFlags & MCI_NOTIFY) {
 362 #ifdef DEBUG_MCIMIDI
 363                 printf("MIDI_mciPlay // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
 364 #endif
 365                 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 366                         MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 367                 exit(1);
 368                 }
 369         return 0;
 370 #else
 371         return MMSYSERR_NOTENABLED;
 372 #endif
 373 }
 374
 375
 376 /**************************************************************************
 377 *                               MIDI_mciRecord                  [internal]
 378 */
 379 DWORD MIDI_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms)
 380 {
 381 #ifdef linux
 382         int                     count;
 383         int                     start, end;
 384         LPMIDIHDR       lpMidiHdr;
 385         DWORD           dwRet;
 386 #ifdef DEBUG_MCIMIDI
 387         printf("MIDI_mciRecord(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
 388 #endif
 389         if (MCIMidiDev[wDevID].hFile == 0) {
 390                 printf("MIDI_mciRecord // can't find file='%s' !\n",
 391                                 MCIMidiDev[wDevID].openParms.lpstrElementName);
 392                 return MCIERR_FILE_NOT_FOUND;
 393                 }
 394         start = 1;              end = 99999;
 395         if (dwFlags & MCI_FROM) {
 396                 start = lpParms->dwFrom;
 397                 printf("MIDI_mciRecord // MCI_FROM=%d \n", start);
 398                 }
 399         if (dwFlags & MCI_TO) {
 400                 end = lpParms->dwTo;
 401                 printf("MIDI_mciRecord // MCI_TO=%d \n", end);
 402                 }
 403         lpMidiHdr = &MCIMidiDev[wDevID].MidiHdr;
 404         lpMidiHdr->lpData = (LPSTR) malloc(64000);
 405         lpMidiHdr->dwBufferLength = 32000;
 406         lpMidiHdr->dwUser = 0L;
 407         lpMidiHdr->dwFlags = 0L;
 408         dwRet = midMessage(0, MIDM_PREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
 409         printf("MIDI_mciRecord // after MIDM_PREPARE \n");
 410         MCIMidiDev[wDevID].dwStatus = MCI_MODE_RECORD;
 411         while(MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) {
 412                 printf("MIDI_mciRecord // MCIMidiDev[wDevID].dwStatus=%p %d\n",
 413                         &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus);
 414                 lpMidiHdr->dwBytesRecorded = 0;
 415                 dwRet = midMessage(0, MIDM_START, 0, 0L, 0L);
 416                 printf("MIDI_mciRecord // after MIDM_START lpMidiHdr=%08X dwBytesRecorded=%u\n",
 417                                         lpMidiHdr, lpMidiHdr->dwBytesRecorded);
 418                 if (lpMidiHdr->dwBytesRecorded == 0) break;
 419                 }
 420         printf("MIDI_mciRecord // before MIDM_UNPREPARE \n");
 421         dwRet = midMessage(0, MIDM_UNPREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
 422         printf("MIDI_mciRecord // after MIDM_UNPREPARE \n");
 423         if (lpMidiHdr->lpData != NULL) {
 424                 free(lpMidiHdr->lpData);
 425                 lpMidiHdr->lpData = NULL;
 426                 }
 427         MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
 428         if (dwFlags & MCI_NOTIFY) {
 429 #ifdef DEBUG_MCIMIDI
 430                 printf("MIDI_mciRecord // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
 431 #endif
 432                 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 433                         MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 434                 }
 435         return 0;
 436 #else
 437         return MMSYSERR_NOTENABLED;
 438 #endif
 439 }
 440
 441
 442 /**************************************************************************
 443 *                               MIDI_mciStop                    [internal]
 444 */
 445 DWORD MIDI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 446 {
 447 #ifdef linux
 448 #ifdef DEBUG_MCIMIDI
 449         printf("MIDI_mciStop(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
 450 #endif
 451         if (lpParms == NULL) return MCIERR_INTERNAL;
 452         MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
 453         printf("MIDI_mciStop // MCIMidiDev[wDevID].dwStatus=%p %d\n",
 454                         &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus);
 455         return 0;
 456 #else
 457         return MCIERR_INTERNAL;
 458 #endif
 459 }
 460
 461
 462 /**************************************************************************
 463 *                               MIDI_mciPause                   [internal]
 464 */
 465 DWORD MIDI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 466 {
 467 #ifdef linux
 468 #ifdef DEBUG_MCIMIDI
 469         printf("MIDI_mciPause(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
 470 #endif
 471         if (lpParms == NULL) return MCIERR_INTERNAL;
 472         return 0;
 473 #else
 474         return MCIERR_INTERNAL;
 475 #endif
 476 }
 477
 478
 479 /**************************************************************************
 480 *                               MIDI_mciResume                  [internal]
 481 */
 482 DWORD MIDI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 483 {
 484 #ifdef linux
 485 #ifdef DEBUG_MCIMIDI
 486         printf("MIDI_mciResume(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
 487 #endif
 488         if (lpParms == NULL) return MCIERR_INTERNAL;
 489         return 0;
 490 #else
 491         return MCIERR_INTERNAL;
 492 #endif
 493 }
 494
 495
 496 /**************************************************************************
 497 *                               MIDI_mciSet                     [internal]
 498 */
 499 DWORD MIDI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
 500 {
 501 #ifdef linux
 502 #ifdef DEBUG_MCIMIDI
 503         printf("MIDI_mciSet(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
 504 #endif
 505         if (lpParms == NULL) return MCIERR_INTERNAL;
 506 #ifdef DEBUG_MCIMIDI
 507         printf("MIDI_mciSet // dwTimeFormat=%08X\n", lpParms->dwTimeFormat);
 508         printf("MIDI_mciSet // dwAudio=%08X\n", lpParms->dwAudio);
 509 #endif
 510         if (dwFlags & MCI_SET_TIME_FORMAT) {
 511                 switch (lpParms->dwTimeFormat) {
 512                         case MCI_FORMAT_MILLISECONDS:
 513                                 printf("MIDI_mciSet // MCI_FORMAT_MILLISECONDS !\n");
 514                                 break;
 515                         case MCI_FORMAT_BYTES:
 516                                 printf("MIDI_mciSet // MCI_FORMAT_BYTES !\n");
 517                                 break;
 518                         case MCI_FORMAT_SAMPLES:
 519                                 printf("MIDI_mciSet // MCI_FORMAT_SAMPLES !\n");
 520                                 break;
 521                         default:
 522                                 printf("MIDI_mciSet // bad time format !\n");
 523                                 return MCIERR_BAD_TIME_FORMAT;
 524                         }
 525                 }
 526         if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
 527         if (dwFlags & MCI_SET_DOOR_OPEN) return MCIERR_UNSUPPORTED_FUNCTION;
 528         if (dwFlags & MCI_SET_DOOR_CLOSED) return MCIERR_UNSUPPORTED_FUNCTION;
 529         if (dwFlags & MCI_SET_AUDIO) {
 530                 printf("MIDI_mciSet // MCI_SET_AUDIO !\n");
 531                 }
 532         if (dwFlags && MCI_SET_ON) {
 533                 printf("MIDI_mciSet // MCI_SET_ON !\n");
 534                 if (dwFlags && MCI_SET_AUDIO_LEFT) {
 535                         printf("MIDI_mciSet // MCI_SET_AUDIO_LEFT !\n");
 536                         }
 537                 if (dwFlags && MCI_SET_AUDIO_RIGHT) {
 538                         printf("MIDI_mciSet // MCI_SET_AUDIO_RIGHT !\n");
 539                         }
 540                 }
 541         if (dwFlags & MCI_SET_OFF) {
 542                 printf("MIDI_mciSet // MCI_SET_OFF !\n");
 543                 }
 544         if (dwFlags & MCI_SEQ_SET_MASTER) {
 545                 printf("MIDI_mciSet // MCI_SEQ_SET_MASTER !\n");
 546                 }
 547         if (dwFlags & MCI_SEQ_SET_SLAVE) {
 548                 printf("MIDI_mciSet // MCI_SEQ_SET_SLAVE !\n");
 549                 }
 550         if (dwFlags & MCI_SEQ_SET_OFFSET) {
 551                 printf("MIDI_mciSet // MCI_SEQ_SET_OFFSET !\n");
 552                 }
 553         if (dwFlags & MCI_SEQ_SET_PORT) {
 554                 printf("MIDI_mciSet // MCI_SEQ_SET_PORT !\n");
 555                 }
 556         if (dwFlags & MCI_SEQ_SET_TEMPO) {
 557                 printf("MIDI_mciSet // MCI_SEQ_SET_TEMPO !\n");
 558                 }
 559         return 0;
 560 #else
 561         return MCIERR_INTERNAL;
 562 #endif
 563 }
 564
 565
 566 /**************************************************************************
 567 *                               MIDI_mciStatus          [internal]
 568 */
 569 DWORD MIDI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
 570 {
 571 #ifdef linux
 572 #ifdef DEBUG_MCIMIDI
 573         printf("MIDI_mciStatus(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
 574 #endif
 575         if (lpParms == NULL) return MCIERR_INTERNAL;
 576         if (dwFlags & MCI_STATUS_ITEM) {
 577                 switch(lpParms->dwItem) {
 578                         case MCI_STATUS_CURRENT_TRACK:
 579                                 lpParms->dwReturn = 1;
 580                                 break;
 581                         case MCI_STATUS_LENGTH:
 582                                 lpParms->dwReturn = 5555;
 583                                 if (dwFlags & MCI_TRACK) {
 584                                         lpParms->dwTrack = 1;
 585                                         lpParms->dwReturn = 2222;
 586                                         }
 587                                 break;
 588                         case MCI_STATUS_MODE:
 589                                 lpParms->dwReturn = MCI_MODE_STOP;
 590                                 break;
 591                         case MCI_STATUS_MEDIA_PRESENT:
 592                                 printf("MIDI_mciStatus // MCI_STATUS_MEDIA_PRESENT !\n");
 593                                 lpParms->dwReturn = TRUE;
 594                                 break;
 595                         case MCI_STATUS_NUMBER_OF_TRACKS:
 596                                 lpParms->dwReturn = 1;
 597                                 break;
 598                         case MCI_STATUS_POSITION:
 599                                 lpParms->dwReturn = 3333;
 600                                 if (dwFlags & MCI_STATUS_START) {
 601                                         lpParms->dwItem = 1;
 602                                         }
 603                                 if (dwFlags & MCI_TRACK) {
 604                                         lpParms->dwTrack = 1;
 605                                         lpParms->dwReturn = 777;
 606                                         }
 607                                 break;
 608                         case MCI_STATUS_READY:
 609                                 printf("MIDI_mciStatus // MCI_STATUS_READY !\n");
 610                                 lpParms->dwReturn = TRUE;
 611                                 break;
 612                         case MCI_STATUS_TIME_FORMAT:
 613                                 printf("MIDI_mciStatus // MCI_STATUS_TIME_FORMAT !\n");
 614                                 lpParms->dwReturn = MCI_FORMAT_MILLISECONDS;
 615                                 break;
 616                         case MCI_SEQ_STATUS_DIVTYPE:
 617                                 printf("MIDI_mciStatus // MCI_SEQ_STATUS_DIVTYPE !\n");
 618                                 lpParms->dwReturn = 0;
 619                                 break;
 620                         case MCI_SEQ_STATUS_MASTER:
 621                                 printf("MIDI_mciStatus // MCI_SEQ_STATUS_MASTER !\n");
 622                                 lpParms->dwReturn = 0;
 623                                 break;
 624                         case MCI_SEQ_STATUS_SLAVE:
 625                                 printf("MIDI_mciStatus // MCI_SEQ_STATUS_SLAVE !\n");
 626                                 lpParms->dwReturn = 0;
 627                                 break;
 628                         case MCI_SEQ_STATUS_OFFSET:
 629                                 printf("MIDI_mciStatus // MCI_SEQ_STATUS_OFFSET !\n");
 630                                 lpParms->dwReturn = 0;
 631                                 break;
 632                         case MCI_SEQ_STATUS_PORT:
 633                                 printf("MIDI_mciStatus // MCI_SEQ_STATUS_PORT !\n");
 634                                 lpParms->dwReturn = 0;
 635                                 break;
 636                         case MCI_SEQ_STATUS_TEMPO:
 637                                 printf("MIDI_mciStatus // MCI_SEQ_STATUS_TEMPO !\n");
 638                                 lpParms->dwReturn = 0;
 639                                 break;
 640                         default:
 641                                 printf("MIDI_mciStatus // unknowm command %04X !\n", lpParms->dwItem);
 642                                 return MCIERR_UNRECOGNIZED_COMMAND;
 643                         }
 644                 }
 645         if (dwFlags & MCI_NOTIFY) {
 646                 printf("MIDI_mciStatus // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
 647                 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 648                         MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 649                 }
 650         return 0;
 651 #else
 652         return MCIERR_INTERNAL;
 653 #endif
 654 }
 655
 656 /**************************************************************************
 657 *                               MIDI_mciGetDevCaps              [internal]
 658 */
 659 DWORD MIDI_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
 660                                         LPMCI_GETDEVCAPS_PARMS lpParms)
 661 {
 662 #ifdef linux
 663         printf("MIDI_mciGetDevCaps(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
 664         if (lpParms == NULL) return MCIERR_INTERNAL;
 665         if (dwFlags & MCI_GETDEVCAPS_ITEM) {
 666                 switch(lpParms->dwItem) {
 667                         case MCI_GETDEVCAPS_CAN_RECORD:
 668                                 lpParms->dwReturn = TRUE;
 669                                 break;
 670                         case MCI_GETDEVCAPS_HAS_AUDIO:
 671                                 lpParms->dwReturn = TRUE;
 672                                 break;
 673                         case MCI_GETDEVCAPS_HAS_VIDEO:
 674                                 lpParms->dwReturn = FALSE;
 675                                 break;
 676                         case MCI_GETDEVCAPS_DEVICE_TYPE:
 677                                 lpParms->dwReturn = MCI_DEVTYPE_SEQUENCER;
 678                                 break;
 679                         case MCI_GETDEVCAPS_USES_FILES:
 680                                 lpParms->dwReturn = TRUE;
 681                                 break;
 682                         case MCI_GETDEVCAPS_COMPOUND_DEVICE:
 683                                 lpParms->dwReturn = TRUE;
 684                                 break;
 685                         case MCI_GETDEVCAPS_CAN_EJECT:
 686                                 lpParms->dwReturn = FALSE;
 687                                 break;
 688                         case MCI_GETDEVCAPS_CAN_PLAY:
 689                                 lpParms->dwReturn = TRUE;
 690                                 break;
 691                         case MCI_GETDEVCAPS_CAN_SAVE:
 692                                 lpParms->dwReturn = FALSE;
 693                                 break;
 694                         default:
 695                                 return MCIERR_UNRECOGNIZED_COMMAND;
 696                         }
 697                 }
 698         return 0;
 699 #else
 700         return MCIERR_INTERNAL;
 701 #endif
 702 }
 703
 704 /**************************************************************************
 705 *                               MIDI_mciInfo                    [internal]
 706 */
 707 DWORD MIDI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms)
 708 {
 709 #ifdef linux
 710         printf("MIDI_mciInfo(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
 711         if (lpParms == NULL) return MCIERR_INTERNAL;
 712         lpParms->lpstrReturn = NULL;
 713         switch(dwFlags) {
 714                 case MCI_INFO_PRODUCT:
 715                         lpParms->lpstrReturn = "Linux Sound System 0.5";
 716                         break;
 717                 case MCI_INFO_FILE:
 718                         lpParms->lpstrReturn = "FileName";
 719                         break;
 720                 default:
 721                         return MCIERR_UNRECOGNIZED_COMMAND;
 722                 }
 723         if (lpParms->lpstrReturn != NULL)
 724                 lpParms->dwRetSize = strlen(lpParms->lpstrReturn);
 725         else
 726                 lpParms->dwRetSize = 0;
 727         return 0;
 728 #else
 729         return MCIERR_INTERNAL;
 730 #endif
 731 }
 732
 733
 734 /*-----------------------------------------------------------------------*/
 735
 736
 737 /**************************************************************************
 738 *                               midGetDevCaps                   [internal]
 739 */
 740 DWORD midGetDevCaps(WORD wDevID, LPMIDIINCAPS lpCaps, DWORD dwSize)
 741 {
 742         printf("midGetDevCaps(%u, %08X, %08X);\n", wDevID, lpCaps, dwSize);
 743         return MMSYSERR_NOTENABLED;
 744 }
 745
 746 /**************************************************************************
 747 *                               midOpen                                 [internal]
 748 */
 749 DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 750 {
 751         printf("modOpen(%u, %08X, %08X);\n", wDevID, lpDesc, dwFlags);
 752         return MMSYSERR_NOTENABLED;
 753 }
 754
 755 /**************************************************************************
 756 *                               midClose                                [internal]
 757 */
 758 DWORD midClose(WORD wDevID)
 759 {
 760         printf("midClose(%u);\n", wDevID);
 761         return MMSYSERR_NOTENABLED;
 762 }
 763
 764 /**************************************************************************
 765 *                               midAddBuffer            [internal]
 766 */
 767 DWORD midAddBuffer(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 768 {
 769         printf("midAddBuffer(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
 770         return MMSYSERR_NOTENABLED;
 771 }
 772
 773 /**************************************************************************
 774 *                               midPrepare                      [internal]
 775 */
 776 DWORD midPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 777 {
 778         printf("midPrepare(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
 779         return MMSYSERR_NOTENABLED;
 780 }
 781
 782 /**************************************************************************
 783 *                               midUnprepare                    [internal]
 784 */
 785 DWORD midUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 786 {
 787         printf("midUnprepare(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
 788         return MMSYSERR_NOTENABLED;
 789 }
 790
 791 /**************************************************************************
 792 *                               midReset                                [internal]
 793 */
 794 DWORD midReset(WORD wDevID)
 795 {
 796         printf("midReset(%u);\n", wDevID);
 797         return MMSYSERR_NOTENABLED;
 798 }
 799
 800
 801 /**************************************************************************
 802 *                               midStart                                [internal]
 803 */
 804 DWORD midStart(WORD wDevID)
 805 {
 806         printf("midStart(%u);\n", wDevID);
 807         return MMSYSERR_NOTENABLED;
 808 }
 809
 810
 811 /**************************************************************************
 812 *                               midStop                                 [internal]
 813 */
 814 DWORD midStop(WORD wDevID)
 815 {
 816         printf("midStop(%u);\n", wDevID);
 817         return MMSYSERR_NOTENABLED;
 818 }
 819
 820
 821 /**************************************************************************
 822 *                               midMessage                              [sample driver]
 823 */
 824 DWORD midMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
 825                                         DWORD dwParam1, DWORD dwParam2)
 826 {
 827         printf("midMessage(%u, %04X, %08X, %08X, %08X);\n",
 828                         wDevID, wMsg, dwUser, dwParam1, dwParam2);
 829         switch(wMsg) {
 830                 case MIDM_OPEN:
 831                         return midOpen(wDevID, (LPMIDIOPENDESC)dwParam1, dwParam2);
 832                 case MIDM_CLOSE:
 833                         return midClose(wDevID);
 834                 case MIDM_ADDBUFFER:
 835                         return midAddBuffer(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
 836                 case MIDM_PREPARE:
 837                         return midPrepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
 838                 case MIDM_UNPREPARE:
 839                         return midUnprepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
 840                 case MIDM_GETDEVCAPS:
 841                         return midGetDevCaps(wDevID, (LPMIDIINCAPS)dwParam1, dwParam2);
 842                 case MIDM_GETNUMDEVS:
 843                         return 1L;
 844                 case MIDM_RESET:
 845                         return midReset(wDevID);
 846                 case MIDM_START:
 847                         return midStart(wDevID);
 848                 case MIDM_STOP:
 849                         return midStop(wDevID);
 850                 }
 851         return MMSYSERR_NOTSUPPORTED;
 852 }
 853
 854
 855
 856 /*-----------------------------------------------------------------------*/
 857
 858
 859 /**************************************************************************
 860 *                               modGetDevCaps                   [internal]
 861 */
 862 DWORD modGetDevCaps(WORD wDevID, LPMIDIOUTCAPS lpCaps, DWORD dwSize)
 863 {
 864         printf("modGetDevCaps(%u, %08X, %08X);\n", wDevID, lpCaps, dwSize);
 865         return MMSYSERR_NOTENABLED;
 866 }
 867
 868
 869 /**************************************************************************
 870 *                               modOpen                                 [internal]
 871 */
 872 DWORD modOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 873 {
 874         printf("modOpen(%u, %08X, %08X);\n", wDevID, lpDesc, dwFlags);
 875         return MMSYSERR_NOTENABLED;
 876 }
 877
 878
 879 /**************************************************************************
 880 *                               modClose                                [internal]
 881 */
 882 DWORD modClose(WORD wDevID)
 883 {
 884         printf("modClose(%u);\n", wDevID);
 885         return MMSYSERR_NOTENABLED;
 886 }
 887
 888 /**************************************************************************
 889 *                               modData                                 [internal]
 890 */
 891 DWORD modData(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 892 {
 893         printf("modData(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
 894         return MMSYSERR_NOTENABLED;
 895 }
 896
 897 /**************************************************************************
 898 *                               modLongData                                     [internal]
 899 */
 900 DWORD modLongData(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 901 {
 902         printf("modLongData(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
 903         return MMSYSERR_NOTENABLED;
 904 }
 905
 906 /**************************************************************************
 907 *                               modPrepare                              [internal]
 908 */
 909 DWORD modPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 910 {
 911         printf("modPrepare(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
 912         return MMSYSERR_NOTENABLED;
 913 }
 914
 915 /**************************************************************************
 916 *                               modUnprepare                    [internal]
 917 */
 918 DWORD modUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 919 {
 920         printf("modUnprepare(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
 921         return MMSYSERR_NOTENABLED;
 922 }
 923
 924 /**************************************************************************
 925 *                               modReset                                [internal]
 926 */
 927 DWORD modReset(WORD wDevID)
 928 {
 929         printf("modReset(%u);\n", wDevID);
 930         return MMSYSERR_NOTENABLED;
 931 }
 932
 933
 934 /**************************************************************************
 935 *                               modGetPosition                  [internal]
 936 */
 937 DWORD modGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
 938 {
 939         printf("modGetposition(%u, %08X, %08X);\n", wDevID, lpTime, uSize);
 940         return MMSYSERR_NOTENABLED;
 941 }
 942
 943
 944 /**************************************************************************
 945 *                               modMessage                      [sample driver]
 946 */
 947 DWORD modMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
 948                                         DWORD dwParam1, DWORD dwParam2)
 949 {
 950         printf("modMessage(%u, %04X, %08X, %08X, %08X);\n",
 951                         wDevID, wMsg, dwUser, dwParam1, dwParam2);
 952         switch(wMsg) {
 953                 case MODM_OPEN:
 954                         return modOpen(wDevID, (LPMIDIOPENDESC)dwParam1, dwParam2);
 955                 case MODM_CLOSE:
 956                         return modClose(wDevID);
 957                 case MODM_DATA:
 958                         return modData(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
 959                 case MODM_LONGDATA:
 960                         return modLongData(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
 961                 case MODM_PREPARE:
 962                         return modPrepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
 963                 case MODM_UNPREPARE:
 964                         return modUnprepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
 965                 case MODM_GETDEVCAPS:
 966                         return modGetDevCaps(wDevID, (LPMIDIOUTCAPS)dwParam1, dwParam2);
 967                 case MODM_GETNUMDEVS:
 968                         return 1L;
 969                 case MODM_GETVOLUME:
 970                         return 0L;
 971                 case MODM_SETVOLUME:
 972                         return 0L;
 973                 case MODM_RESET:
 974                         return modReset(wDevID);
 975                 }
 976         return MMSYSERR_NOTSUPPORTED;
 977 }
 978
 979
 980 /*-----------------------------------------------------------------------*/
 981
 982
 983 #endif /* #ifdef BUILTIN_MMSYSTEM */