dll/win32/beepmidi/beepmidi.c

   1 /*
   2     BeepMidi :: beep.sys MIDI player
   3
   4     (c) Andrew Greenwood, 2007.
   5
   6     Released as open-source software. You may copy, re-distribute and modify
   7     this software, provided this copyright notice remains intact.
   8
   9     Please see the included README.TXT for more information
  10
  11     HISTORY :
  12         16th January 2007   Started
  13         17th January 2007   Polyphony support and threading added
  14         18th January 2007   Made threading optional, added comments
  15 */
  16
  17 /* The timeslice to allocate for all playing notes (in milliseconds) */
  18 #define TIMESLICE_SIZE  60
  19
  20 /*
  21     If this is defined, notes are added to the playing list, even if
  22     they already exist. As a result, the note will sound twice during
  23     each timeslice. Also each note on will require a corresponding note
  24     off event.
  25 */
  26 #define ALLOW_DUPLICATE_NOTES
  27
  28 /*
  29     The maximum number of notes that may be playing at any one time.
  30     Higher values result in a messier sound as all the frequencies get
  31     mashed together. Do not set this below 2. Recommended = 4
  32 */
  33 #define POLYPHONY   3
  34
  35 /*
  36     Define CONTINUOUS_NOTES to perform note playback in a separate thread.
  37     This was originally the intended behaviour, but after experimentation
  38     doesn't sound as good for MIDI files which have a lot going on. If not
  39     defined, all playing notes are output in sequence as a new note starts.
  40 */
  41 #define CONTINUOUS_NOTES
  42
  43 #define WIN32_NO_STATUS
  44 #define NTOS_MODE_USER
  45 #include <windows.h>
  46 #include <ndk/ntndk.h>
  47 #include <stdio.h>
  48 #include <ntddbeep.h>
  49 #include <math.h>
  50
  51 #include <mmddk.h>
  52 #include <mmsystem.h>
  53
  54 /*#define DPRINT printf*/
  55 #define DPRINT FakePrintf
  56
  57 /* A few MIDI command categories */
  58 #define MIDI_NOTE_OFF       0x80
  59 #define MIDI_NOTE_ON        0x90
  60 #define MIDI_CONTROL_CHANGE 0xB0
  61 #define MIDI_PROGRAM        0xC0
  62 #define MIDI_PITCH_BEND     0xE0
  63 #define MIDI_SYSTEM         0xFF
  64
  65 /* Specific commands */
  66 #define MIDI_RESET          0xFF
  67
  68
  69 typedef struct _NoteNode
  70 {
  71     struct _NoteNode* next;
  72     struct _NoteNode* previous;
  73
  74     UCHAR note;
  75     UCHAR velocity; /* 0 is note-off */
  76 } NoteNode;
  77
  78 typedef struct _DeviceInfo
  79 {
  80     HDRVR mme_handle;
  81     HANDLE kernel_device;
  82
  83     DWORD callback;
  84     DWORD instance;
  85     DWORD flags;
  86
  87     UCHAR running_status;
  88
  89     DWORD playing_notes_count;
  90     NoteNode* note_list;
  91     BOOL refresh_notes;
  92
  93     HANDLE thread_handle;
  94     BOOL terminate_thread;
  95     HANDLE thread_termination_complete;
  96 } DeviceInfo;
  97
  98 DeviceInfo* the_device;
  99 CRITICAL_SECTION device_lock;
 100
 101 void
 102 FakePrintf(char* str, ...)
 103 {
 104     /* Just to shut the compiler up */
 105 }
 106
 107
 108 /*
 109     This is designed to be treated as a thread, however it behaves as a
 110     normal function if CONTINUOUS_NOTES is not defined.
 111 */
 112
 113 DWORD WINAPI
 114 ProcessPlayingNotes(
 115     LPVOID parameter)
 116 {
 117     DeviceInfo* device_info = (DeviceInfo*) parameter;
 118     NTSTATUS status;
 119     IO_STATUS_BLOCK io_status_block;
 120     DWORD arp_notes;
 121
 122     DPRINT("Note processing started\n");
 123
 124     /* We lock the note list only while accessing it */
 125
 126 #ifdef CONTINUOUS_NOTES
 127     while ( ! device_info->terminate_thread )
 128 #endif
 129     {
 130         NoteNode* node;
 131
 132         /* Number of notes being arpeggiated */
 133         arp_notes = 1;
 134
 135         EnterCriticalSection(&device_lock);
 136
 137         /* Calculate how much time to allocate to each playing note */
 138
 139         DPRINT("%d notes active\n", (int) device_info->playing_notes_count);
 140
 141         node = device_info->note_list;
 142
 143         while ( ( node != NULL ) && ( arp_notes <= POLYPHONY ) )
 144         {
 145             BEEP_SET_PARAMETERS beep_data;
 146             DWORD actually_playing = 0;
 147
 148             double frequency = node->note;
 149
 150             DPRINT("playing..\n");
 151
 152             frequency = frequency / 12;
 153             frequency = pow(2, frequency);
 154             frequency = 8.1758 * frequency;
 155
 156             if (device_info->playing_notes_count > POLYPHONY)
 157                 actually_playing = POLYPHONY;
 158             else
 159                 actually_playing = device_info->playing_notes_count;
 160
 161             DPRINT("Frequency %f\n", frequency);
 162
 163             // TODO
 164             beep_data.Frequency = (DWORD) frequency;
 165             beep_data.Duration = TIMESLICE_SIZE / actually_playing; /* device_info->playing_notes_count; */
 166
 167             status = NtDeviceIoControlFile(device_info->kernel_device,
 168                                            NULL,
 169                                            NULL,
 170                                            NULL,
 171                                            &io_status_block,
 172                                            IOCTL_BEEP_SET,
 173                                            &beep_data,
 174                                            sizeof(BEEP_SET_PARAMETERS),
 175                                            NULL,
 176                                            0);
 177
 178             if ( ! NT_SUCCESS(status) )
 179             {
 180                 DPRINT("ERROR %d\n", (int) GetLastError());
 181             }
 182
 183             SleepEx(beep_data.Duration, TRUE);
 184
 185             if ( device_info->refresh_notes )
 186             {
 187                 device_info->refresh_notes = FALSE;
 188                 break;
 189             }
 190
 191             arp_notes ++;
 192             node = node->next;
 193         }
 194
 195         LeaveCriticalSection(&device_lock);
 196     }
 197
 198 #ifdef CONTINUOUS_NOTES
 199     SetEvent(device_info->thread_termination_complete);
 200 #endif
 201
 202     return 0;
 203 }
 204
 205
 206 /*
 207     Fills a MIDIOUTCAPS structure with information about our device.
 208 */
 209
 210 MMRESULT
 211 GetDeviceCapabilities(
 212     MIDIOUTCAPS* caps)
 213 {
 214     /* These are ignored for now */
 215     caps->wMid = 0;
 216     caps->wPid = 0;
 217
 218     caps->vDriverVersion = 0x0100;
 219
 220     memset(caps->szPname, 0, sizeof(caps->szPname));
 221     memcpy(caps->szPname, L"PC speaker\0", strlen("PC speaker\0") * 2);
 222
 223     caps->wTechnology = MOD_SQSYNTH;
 224
 225     caps->wVoices = 1;              /* We only have one voice */
 226     caps->wNotes = POLYPHONY;
 227     caps->wChannelMask = 0xFFBF;    /* Ignore channel 10 */
 228
 229     caps->dwSupport = 0;
 230
 231     return MMSYSERR_NOERROR;
 232 }
 233
 234
 235 /*
 236     Helper function that just simplifies calling the application making use
 237     of us.
 238 */
 239
 240 BOOL
 241 CallClient(
 242     DeviceInfo* device_info,
 243     DWORD_PTR message,
 244     DWORD_PTR parameter1,
 245     DWORD_PTR parameter2)
 246 {
 247     DPRINT("Calling client - callback 0x%x mmhandle 0x%x\n", (int) device_info->callback, device_info->mme_handle);
 248     return DriverCallback(device_info->callback,
 249                           HIWORD(device_info->flags),
 250                           device_info->mme_handle,
 251                           message,
 252                           device_info->instance,
 253                           parameter1,
 254                           parameter2);
 255
 256 }
 257
 258
 259 /*
 260     Open the kernel-mode device and allocate resources. This opens the
 261     BEEP.SYS kernel device.
 262 */
 263
 264 MMRESULT
 265 OpenDevice(
 266     DeviceInfo** private_data,
 267     MIDIOPENDESC* open_desc,
 268     DWORD flags)
 269 {
 270     NTSTATUS status;
 271     HANDLE heap;
 272     HANDLE kernel_device;
 273     UNICODE_STRING beep_device_name;
 274     OBJECT_ATTRIBUTES attribs;
 275     IO_STATUS_BLOCK status_block;
 276
 277     /* One at a time.. */
 278     if ( the_device )
 279     {
 280         DPRINT("Already allocated\n");
 281         return MMSYSERR_ALLOCATED;
 282     }
 283
 284     /* Make the device name into a unicode string and open it */
 285
 286     RtlInitUnicodeString(&beep_device_name,
 287                             L"\\Device\\Beep");
 288
 289     InitializeObjectAttributes(&attribs,
 290                                 &beep_device_name,
 291                                 0,
 292                                 NULL,
 293                                 NULL);
 294
 295     status = NtCreateFile(&kernel_device,
 296                             FILE_READ_DATA | FILE_WRITE_DATA,
 297                             &attribs,
 298                             &status_block,
 299                             NULL,
 300                             0,
 301                             FILE_SHARE_READ | FILE_SHARE_WRITE,
 302                             FILE_OPEN_IF,
 303                             0,
 304                             NULL,
 305                             0);
 306
 307     if ( ! NT_SUCCESS(status) )
 308     {
 309         DPRINT("Could not connect to BEEP device - %d\n", (int) GetLastError());
 310         return MMSYSERR_ERROR;
 311     }
 312
 313     DPRINT("Opened!\n");
 314
 315     /* Allocate and initialize the device info */
 316
 317     heap = GetProcessHeap();
 318
 319     the_device = HeapAlloc(heap, HEAP_ZERO_MEMORY, sizeof(DeviceInfo));
 320
 321     if ( ! the_device )
 322     {
 323         DPRINT("Out of memory\n");
 324         return MMSYSERR_NOMEM;
 325     }
 326
 327     /* Initialize */
 328     the_device->kernel_device = kernel_device;
 329     the_device->playing_notes_count = 0;
 330     the_device->note_list = NULL;
 331     the_device->thread_handle = 0;
 332     the_device->terminate_thread = FALSE;
 333     the_device->running_status = 0;
 334
 335     // TODO
 336     the_device->mme_handle = (HDRVR) open_desc->hMidi;
 337     the_device->callback = open_desc->dwCallback;
 338     the_device->instance = open_desc->dwInstance;
 339     the_device->flags = flags;
 340
 341     /* Store the pointer in the user data */
 342     *private_data = the_device;
 343
 344     /* This is threading-related code */
 345 #ifdef CONTINUOUS_NOTES
 346     the_device->thread_termination_complete = CreateEvent(NULL, FALSE, FALSE, NULL);
 347
 348     if ( ! the_device->thread_termination_complete )
 349     {
 350         DPRINT("CreateEvent failed\n");
 351         HeapFree(heap, 0, the_device);
 352         return MMSYSERR_NOMEM;
 353     }
 354
 355     the_device->thread_handle = CreateThread(NULL,
 356                                              0,
 357                                              ProcessPlayingNotes,
 358                                              (PVOID) the_device,
 359                                              0,
 360                                              NULL);
 361
 362     if ( ! the_device->thread_handle )
 363     {
 364         DPRINT("CreateThread failed\n");
 365         CloseHandle(the_device->thread_termination_complete);
 366         HeapFree(heap, 0, the_device);
 367         return MMSYSERR_NOMEM;
 368     }
 369 #endif
 370
 371     /* Now we call the client application to say the device is open */
 372     DPRINT("Sending MOM_OPEN\n");
 373     DPRINT("Success? %d\n", (int) CallClient(the_device, MOM_OPEN, 0, 0));
 374
 375     return MMSYSERR_NOERROR;
 376 }
 377
 378
 379 /*
 380     Close the kernel-mode device.
 381 */
 382
 383 MMRESULT
 384 CloseDevice(DeviceInfo* device_info)
 385 {
 386     HANDLE heap = GetProcessHeap();
 387
 388     /* If we're working in threaded mode we need to wait for thread to die */
 389 #ifdef CONTINUOUS_NOTES
 390     the_device->terminate_thread = TRUE;
 391
 392     WaitForSingleObject(the_device->thread_termination_complete, INFINITE);
 393
 394     CloseHandle(the_device->thread_termination_complete);
 395 #endif
 396
 397     /* Let the client application know the device is closing */
 398     DPRINT("Sending MOM_CLOSE\n");
 399     CallClient(device_info, MOM_CLOSE, 0, 0);
 400
 401     NtClose(device_info->kernel_device);
 402
 403     /* Free resources */
 404     HeapFree(heap, 0, device_info);
 405
 406     the_device = NULL;
 407
 408     return MMSYSERR_NOERROR;
 409 }
 410
 411
 412 /*
 413     Removes a note from the playing notes list. If the note is not playing,
 414     we just pretend nothing happened.
 415 */
 416
 417 MMRESULT
 418 StopNote(
 419     DeviceInfo* device_info,
 420     UCHAR note)
 421 {
 422     HANDLE heap = GetProcessHeap();
 423     NoteNode* node;
 424     NoteNode* prev_node = NULL;
 425
 426     DPRINT("StopNote\n");
 427
 428     EnterCriticalSection(&device_lock);
 429
 430     node = device_info->note_list;
 431
 432     while ( node != NULL )
 433     {
 434         if ( node->note == note )
 435         {
 436             /* Found the note - just remove the node from the list */
 437
 438             DPRINT("Stopping note %d\n", (int) node->note);
 439
 440             if ( prev_node != NULL )
 441                 prev_node->next = node->next;
 442             else
 443                 device_info->note_list = node->next;
 444
 445             HeapFree(heap, 0, node);
 446
 447             device_info->playing_notes_count --;
 448
 449             DPRINT("Note stopped - now playing %d notes\n", (int) device_info->playing_notes_count);
 450
 451             LeaveCriticalSection(&device_lock);
 452             device_info->refresh_notes = TRUE;
 453
 454             return MMSYSERR_NOERROR;
 455         }
 456
 457         prev_node = node;
 458         node = node->next;
 459     }
 460
 461     LeaveCriticalSection(&device_lock);
 462
 463     /* Hmm, a good idea? */
 464 #ifndef CONTINUOUS_NOTES
 465     ProcessPlayingNotes((PVOID) device_info);
 466 #endif
 467
 468     return MMSYSERR_NOERROR;
 469 }
 470
 471
 472 /*
 473     Adds a note to the playing notes list. If the note is already playing,
 474     the definition of ALLOW_DUPLICATE_NOTES determines if an existing note
 475     may be duplicated. Otherwise, duplicate notes are ignored.
 476 */
 477
 478 MMRESULT
 479 PlayNote(
 480     DeviceInfo* device_info,
 481     UCHAR note,
 482     UCHAR velocity)
 483 {
 484     HANDLE heap = GetProcessHeap();
 485
 486     NoteNode* node;
 487
 488     DPRINT("PlayNote\n");
 489
 490     if ( velocity == 0 )
 491     {
 492         DPRINT("Zero velocity\n");
 493
 494         /* Velocity zero is effectively a "note off" */
 495         StopNote(device_info, note);
 496     }
 497     else
 498     {
 499         /* Start playing the note */
 500         NoteNode* new_node;
 501         NoteNode* tail_node = NULL;
 502
 503         EnterCriticalSection(&device_lock);
 504
 505         node = device_info->note_list;
 506
 507         while ( node != NULL )
 508         {
 509 #ifndef ALLOW_DUPLICATE_NOTES
 510             if ( ( node->note == note ) && ( velocity > 0 ) )
 511             {
 512                 /* The note is already playing - do nothing */
 513                 DPRINT("Duplicate note playback request ignored\n");
 514                 LeaveCriticalSection(&device_lock);
 515                 return MMSYSERR_NOERROR;
 516             }
 517 #endif
 518
 519             tail_node = node;
 520             node = node->next;
 521         }
 522
 523         new_node = HeapAlloc(heap, HEAP_ZERO_MEMORY, sizeof(NoteNode));
 524
 525         if ( ! new_node )
 526         {
 527             LeaveCriticalSection(&device_lock);
 528             return MMSYSERR_NOMEM;
 529         }
 530
 531         new_node->note = note;
 532         new_node->velocity = velocity;
 533
 534         /*
 535             Prepend to the playing notes list. If exceeding polyphony,
 536             remove the oldest note (which will be at the tail.)
 537         */
 538
 539         if ( device_info->note_list )
 540             device_info->note_list->previous = new_node;
 541
 542         new_node->next = device_info->note_list;
 543         new_node->previous = NULL;
 544
 545         device_info->note_list = new_node;
 546         device_info->playing_notes_count ++;
 547
 548 /*
 549         if ( device_info->playing_notes_count > POLYPHONY )
 550         {
 551             ASSERT(tail_node);
 552
 553             DPRINT("Polyphony exceeded\n");
 554
 555             tail_node->previous->next = NULL;
 556
 557             HeapFree(heap, 0, tail_node);
 558
 559             device_info->playing_notes_count --;
 560         }
 561 */
 562
 563         LeaveCriticalSection(&device_lock);
 564
 565         DPRINT("Note started - now playing %d notes\n", (int) device_info->playing_notes_count);
 566         device_info->refresh_notes = TRUE;
 567     }
 568
 569 #ifndef CONTINUOUS_NOTES
 570     ProcessPlayingNotes((PVOID) device_info);
 571 #endif
 572
 573     return MMSYSERR_NOERROR;
 574 }
 575
 576 /*
 577     Decipher a short MIDI message (which is a MIDI message packed into a DWORD.)
 578     This will set "running status", but does not take this into account when
 579     processing messages (is this necessary?)
 580 */
 581
 582 MMRESULT
 583 ProcessShortMidiMessage(
 584     DeviceInfo* device_info,
 585     DWORD message)
 586 {
 587     DWORD status;
 588
 589     DWORD category;
 590     DWORD channel;
 591     DWORD data1, data2;
 592
 593     status = message & 0x000000FF;
 594
 595     /* Deal with running status */
 596
 597     if ( status < MIDI_NOTE_OFF )
 598     {
 599         status = device_info->running_status;
 600     }
 601
 602     /* Ensure the status is sane! */
 603
 604     if ( status < MIDI_NOTE_OFF )
 605     {
 606         /* It's garbage, ignore it */
 607         return MMSYSERR_NOERROR;
 608     }
 609
 610     /* Figure out the message category and channel */
 611
 612     category = status & 0xF0;
 613     channel = status & 0x0F;    /* we don't use this */
 614
 615     data1 = (message & 0x0000FF00) >> 8;
 616     data2 = (message & 0x00FF0000) >> 16;
 617
 618     DPRINT("0x%x, %d, %d\n", (int) status, (int) data1, (int) data2);
 619
 620     /* Filter drums (which are *usually* on channel 10) */
 621     if ( channel == 10 )
 622     {
 623         return MMSYSERR_NOERROR;
 624     }
 625
 626     /* Pass to the appropriate message handler */
 627
 628     switch ( category )
 629     {
 630         case MIDI_NOTE_ON :
 631         {
 632             PlayNote(device_info, data1, data2);
 633             break;
 634         }
 635
 636         case MIDI_NOTE_OFF :
 637         {
 638             StopNote(device_info, data1);
 639             break;
 640         }
 641     }
 642
 643     return MMSYSERR_NOERROR;
 644 }
 645
 646
 647 #define PACK_MIDI(b1, b2, b3) \
 648     ((b3 * 65536) + (b2 * 256) + b1);
 649
 650
 651 /*
 652     Processes a "long" MIDI message (ie, a MIDI message contained within a
 653     buffer.) This is intended for supporting SysEx data, or blocks of MIDI
 654     events. However in our case we're only interested in short MIDI messages,
 655     so we scan the buffer, and each time we encounter a valid status byte
 656     we start recording it as a new event. Once 3 bytes or a new status is
 657     received, the event is passed to the short message handler.
 658 */
 659
 660 MMRESULT
 661 ProcessLongMidiMessage(
 662     DeviceInfo* device_info,
 663     MIDIHDR* header)
 664 {
 665     unsigned int index = 0;
 666     UCHAR* midi_bytes = (UCHAR*) header->lpData;
 667
 668     unsigned int msg_index = 0;
 669     UCHAR msg[3];
 670
 671     /* Initialize the buffer */
 672     msg[0] = msg[1] = msg[2] = 0;
 673
 674     if ( ! ( header->dwFlags & MHDR_PREPARED ) )
 675     {
 676         DPRINT("Not prepared!\n");
 677         return MIDIERR_UNPREPARED;
 678     }
 679
 680     DPRINT("Processing %d bytes of MIDI\n", (int) header->dwBufferLength);
 681
 682     while ( index < header->dwBufferLength )
 683     {
 684         /* New status byte? ( = new event) */
 685         if ( midi_bytes[index] & 0x80 )
 686         {
 687             DWORD short_msg;
 688
 689             /* Deal with the existing event */
 690
 691             if ( msg[0] & 0x80 )
 692             {
 693                 short_msg = PACK_MIDI(msg[0], msg[1], msg[2]);
 694
 695                 DPRINT("Complete msg is 0x%x %d %d\n", (int) msg[0], (int) msg[1], (int) msg[2]);
 696                 ProcessShortMidiMessage(device_info, short_msg);
 697             }
 698
 699             /* Set new running status and start recording the event */
 700             DPRINT("Set new running status\n");
 701             device_info->running_status = midi_bytes[index];
 702             msg[0] = midi_bytes[index];
 703             msg_index = 1;
 704         }
 705
 706         /* Unexpected data byte? ( = re-use previous status) */
 707         else if ( msg_index == 0 )
 708         {
 709             if ( device_info->running_status & 0x80 )
 710             {
 711                 DPRINT("Retrieving running status\n");
 712                 msg[0] = device_info->running_status;
 713                 msg[1] = midi_bytes[index];
 714                 msg_index = 2;
 715             }
 716             else
 717                 DPRINT("garbage\n");
 718         }
 719
 720         /* Expected data ( = append to message until buffer full) */
 721         else
 722         {
 723             DPRINT("Next byte...\n");
 724             msg[msg_index] = midi_bytes[index];
 725             msg_index ++;
 726
 727             if ( msg_index > 2 )
 728             {
 729                 DWORD short_msg;
 730
 731                 short_msg = PACK_MIDI(msg[0], msg[1], msg[2]);
 732
 733                 DPRINT("Complete msg is 0x%x %d %d\n", (int) msg[0], (int) msg[1], (int) msg[2]);
 734                 ProcessShortMidiMessage(device_info, short_msg);
 735
 736                 /* Reinit */
 737                 msg_index = 0;
 738                 msg[0] = msg[1] = msg[2] = 0;
 739             }
 740         }
 741
 742         index ++;
 743     }
 744
 745     /*
 746         We're meant to clear MHDR_DONE and set MHDR_INQUEUE but since we
 747         deal with everything here and now we might as well just say so.
 748     */
 749     header->dwFlags |= MHDR_DONE;
 750     header->dwFlags &= ~ MHDR_INQUEUE;
 751
 752     DPRINT("Success? %d\n", CallClient(the_device, MOM_DONE, (DWORD_PTR) header, 0));
 753
 754     return MMSYSERR_NOERROR;
 755 }
 756
 757
 758 /*
 759     Exported function that receives messages from WINMM (the MME API.)
 760 */
 761
 762 MMRESULT
 763 FAR PASCAL
 764 modMessage(
 765     UINT device_id,
 766     UINT message,
 767     DWORD_PTR private_data,
 768     DWORD_PTR parameter1,
 769     DWORD_PTR parameter2)
 770 {
 771     switch ( message )
 772     {
 773         case MODM_GETNUMDEVS :
 774         {
 775             /* Only one internal PC speaker device (and even that's too much) */
 776             DPRINT("MODM_GETNUMDEVS\n");
 777             return 1;
 778         }
 779
 780         case MODM_GETDEVCAPS :
 781         {
 782             DPRINT("MODM_GETDEVCAPS\n");
 783             return GetDeviceCapabilities((MIDIOUTCAPS*) parameter1);
 784         }
 785
 786         case MODM_OPEN :
 787         {
 788             DPRINT("MODM_OPEN\n");
 789
 790             return OpenDevice((DeviceInfo**) private_data,
 791                               (MIDIOPENDESC*) parameter1,
 792                               parameter2);
 793         }
 794
 795         case MODM_CLOSE :
 796         {
 797             DPRINT("MODM_CLOSE\n");
 798             return CloseDevice((DeviceInfo*) private_data);
 799         }
 800
 801         case MODM_DATA :
 802         {
 803             return ProcessShortMidiMessage((DeviceInfo*) private_data, parameter1);
 804         }
 805
 806         case MODM_PREPARE :
 807         {
 808             /* We don't bother with this */
 809             MIDIHDR* hdr = (MIDIHDR*) parameter1;
 810             hdr->dwFlags |= MHDR_PREPARED;
 811             return MMSYSERR_NOERROR;
 812         }
 813
 814         case MODM_UNPREPARE :
 815         {
 816             MIDIHDR* hdr = (MIDIHDR*) parameter1;
 817             hdr->dwFlags &= ~MHDR_PREPARED;
 818             return MMSYSERR_NOERROR;
 819         }
 820
 821         case MODM_LONGDATA :
 822         {
 823             DPRINT("LONGDATA\n");
 824             return ProcessLongMidiMessage((DeviceInfo*) private_data, (MIDIHDR*) parameter1);
 825         }
 826
 827         case MODM_RESET :
 828         {
 829             /* TODO */
 830             break;
 831         }
 832     }
 833
 834     DPRINT("Not supported %d\n", message);
 835
 836     return MMSYSERR_NOTSUPPORTED;
 837 }
 838
 839
 840 /*
 841     Driver entrypoint.
 842 */
 843
 844 LONG
 845 FAR PASCAL
 846 DriverProc(
 847     DWORD driver_id,
 848     HDRVR driver_handle,
 849     UINT message,
 850     LONG parameter1,
 851     LONG parameter2)
 852 {
 853     switch ( message )
 854     {
 855         case DRV_LOAD :
 856             DPRINT("DRV_LOAD\n");
 857             the_device = NULL;
 858             return 1L;
 859
 860         case DRV_FREE :
 861             DPRINT("DRV_FREE\n");
 862             return 1L;
 863
 864         case DRV_OPEN :
 865             DPRINT("DRV_OPEN\n");
 866             InitializeCriticalSection(&device_lock);
 867             return 1L;
 868
 869         case DRV_CLOSE :
 870             DPRINT("DRV_CLOSE\n");
 871             return 1L;
 872
 873         case DRV_ENABLE :
 874             DPRINT("DRV_ENABLE\n");
 875             return 1L;
 876
 877         case DRV_DISABLE :
 878             DPRINT("DRV_DISABLE\n");
 879             return 1L;
 880
 881         /*
 882             We don't provide configuration capabilities. This used to be
 883             for things like I/O port, IRQ, DMA settings, etc.
 884         */
 885
 886         case DRV_QUERYCONFIGURE :
 887             DPRINT("DRV_QUERYCONFIGURE\n");
 888             return 0L;
 889
 890         case DRV_CONFIGURE :
 891             DPRINT("DRV_CONFIGURE\n");
 892             return 0L;
 893
 894         case DRV_INSTALL :
 895             DPRINT("DRV_INSTALL\n");
 896             return DRVCNF_RESTART;
 897     };
 898
 899     DPRINT("???\n");
 900
 901     return DefDriverProc(driver_id,
 902                          driver_handle,
 903                          message,
 904                          parameter1,
 905                          parameter2);
 906 }