![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to midi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / mmedia / soundlib|
Return to midi.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / mmedia / soundlib |
1.1 root 1: /*++
2:
3: Copyright (c) 1992 Microsoft Corporation
4:
5: Module Name:
6:
7: midi.c
8:
9: Abstract:
10:
11: This module contains code for playing and recording Midi
12: data.
13:
14: Author:
15:
16: Robin Speed (robinsp) 25-Nov-92
17:
18: Environment:
19:
20: Kernel mode
21:
22: Revision History:
23:
24: --*/
25:
26: #include <soundlib.h>
27: #include <midi.h>
28:
29: //
30: // Internal routines
31: //
32:
33: VOID
34: MidiRecord(
35: IN OUT PMIDI_INFO pMidi,
36: IN OUT PIRP pIrp
37: );
38:
39: //
40: // Macros to assist in safely using our spin lock (midi input only)
41: //
42:
43: #if DBG
44: #define MidiEnter(pMidi) \
45: { \
46: KIRQL OldIrql; \
47: KeAcquireSpinLock(&(pMidi)->DeviceSpinLock, &OldIrql);\
48: ASSERT((pMidi)->LockHeld == FALSE); \
49: (pMidi)->LockHeld = TRUE;
50:
51: #define MidiLeave(pMidi) \
52: ASSERT((pMidi)->LockHeld == TRUE); \
53: (pMidi)->LockHeld = FALSE; \
54: KeReleaseSpinLock(&(pMidi)->DeviceSpinLock, OldIrql);\
55: }
56: #else
57: #define MidiEnter(pMidi) \
58: { \
59: KIRQL OldIrql; \
60: ASSERT((pMidi)->LockHeld == FALSE); \
61: KeAcquireSpinLock(&(pMidi)->DeviceSpinLock, &OldIrql);
62:
63: #define MidiLeave(pMidi) \
64: ASSERT((pMidi)->LockHeld == TRUE); \
65: KeReleaseSpinLock(&(pMidi)->DeviceSpinLock, OldIrql);\
66: }
67: #endif
68:
69:
70: VOID SoundInitMidiIn(
71: IN OUT PMIDI_INFO pMidi,
72: IN PVOID HwContext
73: )
74: /*++
75:
76: Routine Description:
77:
78: Initialize midi input data structure. Assumes the structure is
79: initialized to 0 apart from the hardware routine entries which
80: should have been initialized.
81:
82: Arguments:
83:
84: pMidi - pointer to MIDI_INFO data structure
85:
86: Return Value:
87: None
88:
89: --*/
90: {
91: KeInitializeSpinLock(&pMidi->DeviceSpinLock);
92: InitializeListHead(&pMidi->QueueHead);
93: pMidi->Key = MIDI_INFO_KEY;
94: pMidi->HwContext = HwContext;
95:
96: ASSERTMSG("Midi hardware routines not initialized",
97: pMidi->HwStartMidiIn != NULL &&
98: pMidi->HwStopMidiIn != NULL &&
99: pMidi->HwMidiRead != NULL &&
100: pMidi->HwMidiOut != NULL);
101:
102: }
103:
104:
105: NTSTATUS
106: SoundIoctlGetMidiState(
107: IN OUT PLOCAL_DEVICE_INFO pLDI,
108: IN PIRP pIrp,
109: IN PIO_STACK_LOCATION IrpStack
110: )
111: /*++
112:
113: Routine Description:
114:
115: Get the current state of the device and return it to the caller.
116: This code is COMMON for :
117: Midi in
118: Midi out
119:
120: Arguments:
121:
122: pLDI - Pointer to our own device data
123: pIrp - Pointer to the IO Request Packet
124: IrpStack - Pointer to current stack location
125:
126: Return Value:
127:
128: Status to put into request packet by caller.
129:
130: --*/
131: {
132: PULONG pState;
133:
134: if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG)) {
135: dprintf1(("Supplied buffer to small for requested data"));
136: return STATUS_BUFFER_TOO_SMALL;
137: }
138:
139: //
140: // say how much we're sending back
141: //
142:
143: pIrp->IoStatus.Information = sizeof(ULONG);
144:
145: //
146: // cast the buffer address to the pointer type we want
147: //
148:
149: pState = (PULONG)pIrp->AssociatedIrp.SystemBuffer;
150:
151: //
152: // fill in the info -
153: //
154:
155: *pState = pLDI->State;
156:
157: return STATUS_SUCCESS;
158: }
159:
160:
161: NTSTATUS SoundIoctlMidiPlay(
162: IN OUT PLOCAL_DEVICE_INFO pLDI,
163: IN PIRP pIrp,
164: IN PIO_STACK_LOCATION IrpStack
165: )
166: /*++
167:
168: Routine Description:
169:
170: Play Midi output (if this is an output device).
171: This call is implemented SYNCRHONOUSLY since the device does
172: not support interrupts. However, for MP systems we should really
173: complete the request asynchronously. We do release the spin lock while
174: actually outputting data.
175:
176: Arguments:
177:
178: pLDI - our local device data
179: pIrp - IO request packet
180: IrpStack - The current stack location
181:
182:
183: Return Value:
184:
185: STATUS_SUCCESS - OK
186: STATUS_DEVICE_BUSY - Device in use
187: STATUS_NOT_SUPPORTED - wrong device
188:
189: --*/
190:
191: {
192: PUCHAR pUserBuffer; // Pointer to mapped user buffer
193: ULONG UserBufferSize; // Amount of user data
194: ULONG i; // Buffer index
195: NTSTATUS Status;
196: PMIDI_INFO pMidi;
197:
198: pMidi = pLDI->DeviceSpecificData;
199: Status = STATUS_SUCCESS;
200:
201: //
202: // Check it's valid
203: //
204:
205: if (pLDI->DeviceType != MIDI_OUT) {
206: dprintf1(("Attempt play on input device"));
207: return STATUS_NOT_SUPPORTED;
208: }
209:
210:
211: //
212: // Find the length of the data and the buffer
213: //
214:
215: UserBufferSize =
216: IrpStack->Parameters.DeviceIoControl.InputBufferLength;
217:
218: pUserBuffer = IrpStack->Parameters.DeviceIoControl.Type3InputBuffer;
219:
220:
221: //
222: // Send the data to the device
223: //
224:
225: dprintf4(("Outputting %d Midi bytes", UserBufferSize));
226:
227: //
228: // Our memory is not locked down or checked since we're
229: // executing the call SYNCHRONOUSLY - so we defend here against
230: // bad applications. This is aimed at getting a fast path
231: // for short messages.
232: //
233:
234: try {
235: (*pMidi->HwMidiOut)(pMidi, pUserBuffer, UserBufferSize);
236: } except (EXCEPTION_EXECUTE_HANDLER) {
237: Status = STATUS_ACCESS_VIOLATION;
238: }
239:
240: return Status;
241: }
242:
243:
244:
245: NTSTATUS
246: SoundIoctlMidiRecord(
247: IN OUT PLOCAL_DEVICE_INFO pLDI,
248: IN PIRP pIrp,
249: IN PIO_STACK_LOCATION pIrpStack
250: )
251: /*++
252:
253: Routine Description:
254:
255: Record midi input.
256:
257: The input buffer size is checked
258:
259: If there is still data to be read from the device then read as
260: much as possible and complete the buffer. Otherwise queue
261: the request.
262:
263:
264: Arguments:
265:
266: pLDI - our local device data
267: pIrp - IO request packet
268: IrpStack - The current stack location
269:
270: Return Value:
271:
272: STATUS_BUFFER_TOO_SMALL - Not enough room to record anything
273: STATUS_PENDING - request queued (at least logically).
274: STATUS_NOT_SUPPORTED - wrong device
275:
276: --*/
277: {
278: NTSTATUS Status;
279: PMIDI_INFO pMidi;
280:
281: pMidi = pLDI->DeviceSpecificData;
282:
283: //
284: // confirm we are doing this on the input device!
285: //
286:
287: ASSERT(pLDI->DeviceType == MIDI_IN);
288:
289: //
290: // Check size of buffer
291: //
292: if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength <
293: sizeof(MIDI_DD_INPUT_DATA)) {
294: dprintf1(("Supplied buffer to small for requested data"));
295:
296: return STATUS_BUFFER_TOO_SMALL;
297: }
298:
299: //
300: // Initialize data length.
301: //
302:
303: pIrp->IoStatus.Information = 0;
304:
305: //
306: // See if there's data to complete the request synchronously
307: //
308:
309: MidiEnter(pMidi);
310:
311: if (pMidi->InputBytes != 0) {
312: ASSERT(pMidi->fMidiInStarted);
313:
314: //
315: // If there was data and a free buffer someone else should
316: // have dispatched it !
317: //
318:
319: ASSERT(IsListEmpty(&pMidi->QueueHead));
320:
321: //
322: // Pull our data
323: //
324:
325: MidiRecord(pMidi, pIrp);
326: Status = STATUS_SUCCESS;
327:
328: } else {
329: //
330: // Request not completed - add it to our list and mark it pending
331: //
332:
333: SoundAddIrpToCancellableQ(&pMidi->QueueHead,
334: pIrp,
335: FALSE); // Means insert at tail
336: dprintf3(("irp added"));
337:
338: //
339: // Mark request pending
340: //
341: pIrp->IoStatus.Status = STATUS_PENDING;
342: Status = STATUS_PENDING;
343: IoMarkIrpPending(pIrp);
344: }
345:
346: MidiLeave(pMidi);
347:
348: return Status;
349: }
350:
351:
352:
353: VOID
354: SoundMidiInDeferred(
355: IN PKDPC pDpc,
356: IN PDEVICE_OBJECT pDeviceObject,
357: IN OUT PIRP pIrpDeferred,
358: IN OUT PVOID Context
359: )
360: /*++
361:
362: Routine Description:
363:
364: Process data after a midi input interrupt.
365: If we have started a new batch of data try to grab the first
366: byte.
367: While there is data record it using MidiRecord for each buffer
368: in the queue.
369: The last buffer which has data in it is always completed since
370: we must get data to the application in real time.
371:
372:
373: Arguments:
374:
375: pDpc - Dpc object
376: pDeviceObject - Our device (points to our device extension)
377: pIrpDeferred - Not meaningful here
378: Context - NULL for our Dpcs
379:
380: Return Value:
381:
382: None
383:
384: --*/
385: {
386: //
387: // The job here is just to read the Midi data in until
388: // the top bit is set. The data is sent to the buffers
389: // supplied by the application.
390: //
391:
392: PLOCAL_DEVICE_INFO pLDI;
393: PMIDI_INFO pMidi;
394:
395: pLDI = (PLOCAL_DEVICE_INFO)pDeviceObject->DeviceExtension;
396: pMidi = pLDI->DeviceSpecificData;
397:
398: dprintf4(("("));
399:
400: MidiEnter(pMidi);
401:
402: //
403: // If input is not running something has gone wrong.
404: // (copied from windows 3.1 driver so I assume that
405: // resetting the SB will also cancel any pending interrupt if
406: // we stop midi input)
407: //
408:
409: ASSERT(pMidi->fMidiInStarted);
410:
411: //
412: // Try to grab as many bytes as possible
413: //
414:
415:
416: while (pMidi->InputBytes < sizeof(pMidi->MidiInputByte)) {
417: if ((*pMidi->HwMidiRead)(
418: pMidi,
419: pMidi->MidiInputByte +
420: (pMidi->InputPosition + pMidi->InputBytes) %
421: sizeof(pMidi->MidiInputByte))) {
422: pMidi->InputBytes++;
423: } else {
424: break;
425: }
426: }
427:
428: //
429: // If there is a LOT of data coming in then we expect that
430: // the application will only supply a fairly small number of
431: // buffers at a time. We then pass the buffers back and if
432: // there's still more the buffers are passed in again. This way
433: // other threads get in for long messages. On the other hand
434: // short messages need passing back quickly so 2 buffers should
435: // kept in motion.
436: //
437:
438: //
439: // Loop while there's still data and still somewhere to put it
440: //
441:
442: while (pMidi->InputBytes) {
443:
444: PIRP pIrp;
445:
446: //
447: // Get our next buffer if there is one
448: //
449:
450: pIrp = SoundRemoveFromCancellableQ(&pMidi->QueueHead);
451:
452: if (pIrp == NULL) {
453: break;
454: }
455:
456:
457: //
458: // Try filling it with data. MidiRecord will turn off the
459: // InputAvailable flag if it runs out of data.
460: //
461:
462: MidiRecord(pMidi, pIrp);
463:
464: //
465: // Complete the request
466: //
467:
468: pIrp->IoStatus.Status = STATUS_SUCCESS;
469: IoCompleteRequest(pIrp, IO_SOUND_INCREMENT);
470: }
471:
472: //
473: // Release the spin lock
474: //
475:
476: MidiLeave(pMidi);
477:
478: dprintf4((")"));
479: }
480:
481:
482: NTSTATUS
483: SoundSetMidiInputState(
484: IN OUT PLOCAL_DEVICE_INFO pLDI,
485: IN ULONG State
486: )
487: /*++
488:
489: Routine Description:
490:
491: Perform the state changes for midi input :
492: MIDI_DD_RECORD - Start recording
493: MIDI_DD_TOP - suspend recording
494: MIDI_DD_RESET - suspend recording and cancel buffers
495:
496: Arguments:
497:
498: pLDI - Pointer to local device data
499: State - the new state to set
500:
501: Return Value:
502:
503: Return status for caller
504:
505: --*/
506: {
507: NTSTATUS Status;
508: PMIDI_INFO pMidi;
509:
510: pMidi = pLDI->DeviceSpecificData;
511:
512: switch (State) {
513: case MIDI_DD_RECORD:
514:
515: pMidi->RefTime = SoundGetTime();
516:
517: pMidi->InputBytes = 0; // Clear buffer
518: pMidi->InputPosition = 0;
519:
520: (*pMidi->HwStartMidiIn)(pLDI->DeviceSpecificData);
521: pLDI->State = MIDI_DD_RECORDING;
522: pMidi->fMidiInStarted = TRUE;
523: Status = STATUS_SUCCESS;
524: dprintf3(("Midi Input started"));
525: break;
526:
527: case MIDI_DD_STOP:
528:
529: (*pMidi->HwStopMidiIn)(pLDI->DeviceSpecificData);
530: pLDI->State = MIDI_DD_STOPPED;
531: pMidi->fMidiInStarted = FALSE;
532: pMidi->InputBytes = 0;
533: Status = STATUS_SUCCESS;
534: dprintf3(("Midi Input stopped"));
535: break;
536:
537: case MIDI_DD_RESET:
538:
539: (*pMidi->HwStopMidiIn)(pLDI->DeviceSpecificData);
540: pLDI->State = MIDI_DD_STOPPED;
541: pMidi->fMidiInStarted = FALSE;
542: pMidi->InputBytes = 0;
543:
544: //
545: // Free any pending Irps.
546: //
547:
548: SoundFreeQ(&pMidi->QueueHead, STATUS_CANCELLED);
549:
550: Status = STATUS_SUCCESS;
551: dprintf3(("Midi Input reset"));
552: break;
553:
554: default:
555:
556: dprintf1(("Bogus set midi input state request: %08lXH", State));
557: Status = STATUS_INVALID_PARAMETER;
558: break;
559: }
560:
561: return Status;
562: }
563:
564:
565:
566: VOID
567: MidiRecord(
568: IN OUT PMIDI_INFO pMidi,
569: IN OUT PIRP pIrp
570: )
571: /*++
572:
573: Routine Description:
574:
575: Read midi input data into user's buffer. The time stamp field
576: in the user's buffer is also filled in. See ntddmidi.h.
577:
578: Arguments:
579:
580: pMidi - Pointer to global device data
581:
582: Return Value:
583:
584: None
585:
586: --*/
587: {
588: int i;
589: int BufferLength;
590:
591: PMIDI_DD_INPUT_DATA pData;
592:
593:
594: pData = (PMIDI_DD_INPUT_DATA)
595: MmGetSystemAddressForMdl(pIrp->MdlAddress);
596:
597: //
598: // Find out how much room we've got for our data
599: //
600: {
601: PIO_STACK_LOCATION pIrpStack;
602:
603: pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
604: BufferLength =
605: pIrpStack->Parameters.Read.Length -
606: FIELD_OFFSET(MIDI_DD_INPUT_DATA, Data[0]);
607:
608: ASSERT(BufferLength > 0);
609: }
610:
611:
612: //
613: // Try filling it with data. MidiRecord will turn off the
614: // InputActive flag if it runs out of data. There must be
615: // at least one byte of data available because callers are
616: // expecting to complete the Irp on return with data
617: //
618:
619: ASSERT(pMidi->InputBytes != 0);
620:
621: //
622: // Remember the time
623: //
624:
625: pData->Time = RtlLargeIntegerSubtract(SoundGetTime(), pMidi->RefTime);
626:
627: //
628: // Read bytes until exhaused or buffer full
629: //
630:
631: for (i = 0; pMidi->InputBytes != 0 && i < BufferLength; i++) {
632: //
633: // Record the byte
634: //
635:
636: pData->Data[i] = pMidi->MidiInputByte[pMidi->InputPosition];
637: pMidi->InputPosition =
638: (pMidi->InputPosition + 1) % sizeof(pMidi->MidiInputByte);
639:
640: pMidi->InputBytes--;
641:
642: dprintf4(("%2X", (ULONG)pData->Data[i]));
643:
644: //
645: // Try to read our next byte
646: //
647:
648: if (pMidi->InputBytes == 0) {
649: pMidi->InputPosition = 0;
650:
651: //
652: // Read as many bytes as we can
653: //
654:
655: while (pMidi->InputBytes < sizeof(pMidi->MidiInputByte)) {
656:
657: if ((*pMidi->HwMidiRead)(
658: pMidi,
659: pMidi->MidiInputByte + pMidi->InputBytes)) {
660: pMidi->InputBytes++;
661: } else {
662: break;
663: }
664: }
665: }
666: }
667:
668: //
669: // Record the amount of data returned in the Irp
670: // The caller will complete the request.
671:
672: pIrp->IoStatus.Information = i + sizeof(LARGE_INTEGER);
673: }
674:
675:
676:
677: VOID
678: SoundMidiReset(
679: IN OUT PMIDI_INFO pMidi
680: )
681: /*++
682:
683: Routine Description:
684:
685: Reset midi output state
686:
687: Arguments:
688:
689: pMidi - Pointer to Midi device data
690:
691: Return Value:
692:
693: None
694:
695: --*/
696: {
697: int i, j;
698: //
699: // Send a note off to each key on each channel
700: // !!! this is not recommended by the midi spec !!!
701: //
702: for (i = 0; i < 16; i++) {
703:
704: UCHAR Data[4 + 256];
705:
706: // Turn the damper pedal off (sustain)
707:
708: Data[0] = (UCHAR)(0xB0 + i); // Control change status byte
709: Data[1] = 0x40; // Control number for sustain
710: Data[2] = 0x00; // value (0 = off)
711:
712: // Send note off for each key
713:
714: Data[3] = (UCHAR)(0x80 + i); // Note off status byte
715:
716: for (j = 0; j < 128; j++) {
717: Data[4 + j * 2] = (UCHAR)j; // Key number
718: Data[4 + j * 2 + 1] = 0x40; // Velocity (64 recommended)
719: }
720:
721: (*pMidi->HwMidiOut)(pMidi, Data, sizeof(Data));
722: }
723: }
724:
725:
726:
727: NTSTATUS
728: SoundMidiDispatch(
729: IN OUT PLOCAL_DEVICE_INFO pLDI,
730: IN PIRP pIrp,
731: IN PIO_STACK_LOCATION IrpStack
732: )
733: /*++
734:
735: Routine Description:
736:
737: Midi Irp call dispatcher
738:
739: Arguments:
740:
741: pLDI - Pointer to local device data
742: pIrp - Pointer to IO request packet
743: IrpStack - Pointer to current stack location
744:
745: Return Value:
746:
747: Return status from dispatched routine
748:
749: --*/
750: {
751: NTSTATUS Status;
752:
753: Status = STATUS_SUCCESS;
754:
755: switch (IrpStack->MajorFunction) {
756: case IRP_MJ_CREATE:
757: Status = SoundSetShareAccess(pLDI, IrpStack);
758: if (NT_SUCCESS(Status) && IrpStack->FileObject->WriteAccess) {
759:
760: if (pLDI->DeviceType == MIDI_OUT) {
761: //
762: // We can open Midi output
763: //
764: pLDI->State = MIDI_DD_IDLE;
765: dprintf3(("Opened for midi output"));
766: Status = STATUS_SUCCESS;
767: } else {
768: //
769: // Open midi input
770: // Only midi input has state data
771: //
772:
773: PMIDI_INFO pMidi;
774: pMidi = pLDI->DeviceSpecificData;
775:
776: ASSERT(IsListEmpty(&pMidi->QueueHead));
777:
778: pLDI->State = MIDI_DD_STOPPED;
779: ASSERT(!pMidi->fMidiInStarted);
780: dprintf3(("Opened for midi input"));
781: Status = STATUS_SUCCESS;
782: }
783: }
784: break;
785:
786: case IRP_MJ_CLOSE:
787:
788: Status = STATUS_SUCCESS;
789:
790: break;
791:
792: case IRP_MJ_READ:
793:
794: if (pLDI->DeviceType != MIDI_IN) {
795: Status = STATUS_INVALID_DEVICE_REQUEST;
796: } else {
797: if (IrpStack->FileObject->WriteAccess) {
798: Status = SoundIoctlMidiRecord(pLDI, pIrp, IrpStack);
799: } else {
800: Status = STATUS_ACCESS_DENIED;
801: }
802: }
803: break;
804:
805:
806: case IRP_MJ_DEVICE_CONTROL:
807:
808: //
809: // Check that if someone has the device open for 'write' it's
810: // marked as in use
811: //
812:
813: ASSERT(!IrpStack->FileObject->WriteAccess ||
814: (*pLDI->DeviceInit->ExclusionRoutine)(pLDI, SoundExcludeQueryOpen));
815:
816: //
817: // Dispatch the IOCTL function
818: // Note that some IOCTLs only make sense for input or output
819: // devices and not both.
820: // Note that APIs which are possibly asynchronous do not
821: // go through the Irp cleanup at the end here because they
822: // may get completed before returning here or they are made
823: // accessible to other requests by being queued.
824: //
825:
826: switch (IrpStack->Parameters.DeviceIoControl.IoControlCode) {
827:
828: case IOCTL_MIDI_GET_CAPABILITIES:
829: Status = (*pLDI->DeviceInit->DevCapsRoutine)(pLDI, pIrp, IrpStack);
830: break;
831:
832: case IOCTL_MIDI_PLAY:
833: Status = SoundIoctlMidiPlay(pLDI, pIrp, IrpStack);
834: break;
835:
836: case IOCTL_MIDI_SET_STATE:
837: if (IrpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(ULONG)) {
838: dprintf1(("Supplied buffer too small for expected data"));
839: Status = STATUS_BUFFER_TOO_SMALL;
840: } else {
841: PULONG pState;
842:
843: //
844: // cast the buffer address to the pointer type we want
845: //
846:
847: pState = (PULONG)pIrp->AssociatedIrp.SystemBuffer;
848:
849: if (pLDI->DeviceType == MIDI_IN) {
850: Status = SoundSetMidiInputState(pLDI, *pState);
851: } else {
852:
853: switch (*pState) {
854: case MIDI_DD_RESET:
855: //
856: // Sent note-off to all notes
857: //
858: SoundMidiReset(
859: (PMIDI_INFO)pLDI->DeviceSpecificData);
860:
861: break;
862:
863: default:
864: Status = STATUS_INVALID_PARAMETER;
865: }
866: }
867: }
868: break;
869:
870: case IOCTL_MIDI_GET_STATE:
871: Status = SoundIoctlGetMidiState(pLDI, pIrp, IrpStack);
872: break;
873:
874:
875: default:
876: dprintf2(("Unimplemented IOCTL (%08lXH) requested", IrpStack->Parameters.DeviceIoControl.IoControlCode));
877: Status = STATUS_INVALID_DEVICE_REQUEST;
878: break;
879: }
880: break;
881:
882:
883: case IRP_MJ_CLEANUP:
884: if (IrpStack->FileObject->WriteAccess) {
885:
886: PMIDI_INFO pMidi;
887:
888: pMidi = pLDI->DeviceSpecificData;
889:
890: switch (pLDI->DeviceType) {
891: case MIDI_OUT:
892: SoundMidiReset(pMidi);
893: break;
894:
895: case MIDI_IN:
896: (*pMidi->HwStopMidiIn)(pLDI->DeviceSpecificData);
897: pMidi->fMidiInStarted = FALSE;
898: pMidi->InputBytes = 0;
899: SoundFreeQ(&pMidi->QueueHead, STATUS_CANCELLED);
900: break;
901: }
902: pLDI->PreventVolumeSetting = FALSE;
903:
904: (*pLDI->DeviceInit->ExclusionRoutine)(pLDI, SoundExcludeClose);
905:
906: } else {
907: Status = STATUS_SUCCESS;
908: }
909: break;
910:
911:
912: default:
913: dprintf1(("Unimplemented major function requested: %08lXH", IrpStack->MajorFunction));
914: Status = STATUS_INVALID_DEVICE_REQUEST;
915: break;
916: }
917:
918: return Status;
919: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.