xref: /reactos/sdk/lib/drivers/sound/mmixer/midi.c (revision 565bf9e3) 
1 /*
2  * COPYRIGHT:       See COPYING in the top level directory
3  * PROJECT:         ReactOS Kernel Streaming
4  * FILE:            lib/drivers/sound/mmixer/midi.c
5  * PURPOSE:         Midi Support Functions
6  * PROGRAMMER:      Johannes Anderwald
7  */
8 
9 #include "precomp.h"
10 
11 // #define NDEBUG
12 #include <debug.h>
13 
14 MIXER_STATUS
15 MMixerGetPinDataFlowAndCommunication(
16     IN PMIXER_CONTEXT MixerContext,
17     IN HANDLE hDevice,
18     IN ULONG PinId,
19     OUT PKSPIN_DATAFLOW DataFlow,
20     OUT PKSPIN_COMMUNICATION Communication)
21 {
22     KSP_PIN Pin;
23     ULONG BytesReturned;
24     MIXER_STATUS Status;
25 
26     /* setup request */
27     Pin.PinId = PinId;
28     Pin.Reserved = 0;
29     Pin.Property.Flags = KSPROPERTY_TYPE_GET;
30     Pin.Property.Id = KSPROPERTY_PIN_DATAFLOW;
31     Pin.Property.Set = KSPROPSETID_Pin;
32 
33     /* get pin dataflow */
34     Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)DataFlow, sizeof(KSPIN_DATAFLOW), &BytesReturned);
35     if (Status != MM_STATUS_SUCCESS)
36     {
37         /* failed to retrieve dataflow */
38         return Status;
39     }
40 
41     /* setup communication request */
42     Pin.Property.Id = KSPROPERTY_PIN_COMMUNICATION;
43 
44     /* get pin communication */
45     Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)Communication, sizeof(KSPIN_COMMUNICATION), &BytesReturned);
46 
47     return Status;
48 }
49 
50 MIXER_STATUS
51 MMixerAddMidiPin(
52     IN PMIXER_CONTEXT MixerContext,
53     IN PMIXER_LIST MixerList,
54     IN ULONG DeviceId,
55     IN ULONG PinId,
56     IN ULONG bInput,
57     IN LPWSTR DeviceName)
58 {
59     LPMIDI_INFO MidiInfo;
60 
61     /* allocate midi info */
62     MidiInfo = MixerContext->Alloc(sizeof(MIDI_INFO));
63 
64     if (!MidiInfo)
65     {
66         /* no memory */
67         return MM_STATUS_NO_MEMORY;
68     }
69 
70     /* initialize midi info */
71     MidiInfo->DeviceId = DeviceId;
72     MidiInfo->PinId = PinId;
73 
74     /* sanity check */
75     ASSERT(!DeviceName || (wcslen(DeviceName) < MAXPNAMELEN));
76 
77     /* copy device name */
78     if (bInput && DeviceName)
79     {
80         wcscpy(MidiInfo->u.InCaps.szPname, DeviceName);
81     }
82     else if (!bInput && DeviceName)
83     {
84         wcscpy(MidiInfo->u.OutCaps.szPname, DeviceName);
85     }
86 
87    /* FIXME determine manufacturer / product id */
88     if (bInput)
89     {
90         MidiInfo->u.InCaps.dwSupport = 0;
91         MidiInfo->u.InCaps.wMid = MM_MICROSOFT;
92         MidiInfo->u.InCaps.wPid = MM_PID_UNMAPPED;
93         MidiInfo->u.InCaps.vDriverVersion = 1;
94     }
95     else
96     {
97         MidiInfo->u.OutCaps.dwSupport = 0;
98         MidiInfo->u.OutCaps.wMid = MM_MICROSOFT;
99         MidiInfo->u.OutCaps.wPid = MM_PID_UNMAPPED;
100         MidiInfo->u.OutCaps.vDriverVersion = 1;
101     }
102 
103     if (bInput)
104     {
105         /* insert into list */
106         InsertTailList(&MixerList->MidiInList, &MidiInfo->Entry);
107         MixerList->MidiInListCount++;
108     }
109     else
110     {
111         /* insert into list */
112         InsertTailList(&MixerList->MidiOutList, &MidiInfo->Entry);
113         MixerList->MidiOutListCount++;
114     }
115 
116     return MM_STATUS_SUCCESS;
117 }
118 
119 VOID
120 MMixerCheckFilterPinMidiSupport(
121     IN PMIXER_CONTEXT MixerContext,
122     IN PMIXER_LIST MixerList,
123     IN LPMIXER_DATA MixerData,
124     IN ULONG PinId,
125     IN PKSMULTIPLE_ITEM MultipleItem,
126     IN LPWSTR szPname)
127 {
128     ULONG Index;
129     PKSDATARANGE DataRange;
130     KSPIN_COMMUNICATION Communication;
131     KSPIN_DATAFLOW DataFlow;
132 
133     /* get first datarange */
134     DataRange = (PKSDATARANGE)(MultipleItem + 1);
135 
136     /* alignment assert */
137     ASSERT(((ULONG_PTR)DataRange & 0x7) == 0);
138 
139     /* iterate through all data ranges */
140     for(Index = 0; Index < MultipleItem->Count; Index++)
141     {
142         if (IsEqualGUIDAligned(&DataRange->MajorFormat, &KSDATAFORMAT_TYPE_MUSIC) &&
143             IsEqualGUIDAligned(&DataRange->SubFormat, &KSDATAFORMAT_SUBTYPE_MIDI) &&
144             IsEqualGUIDAligned(&DataRange->Specifier, &KSDATAFORMAT_SPECIFIER_NONE))
145         {
146             /* pin supports midi datarange */
147             if (MMixerGetPinDataFlowAndCommunication(MixerContext, MixerData->hDevice, PinId, &DataFlow, &Communication) == MM_STATUS_SUCCESS)
148             {
149                 if (DataFlow == KSPIN_DATAFLOW_IN && Communication == KSPIN_COMMUNICATION_SINK)
150                 {
151                     MMixerAddMidiPin(MixerContext, MixerList, MixerData->DeviceId, PinId, FALSE, szPname);
152                 }
153                 else if (DataFlow == KSPIN_DATAFLOW_OUT && Communication == KSPIN_COMMUNICATION_SOURCE)
154                 {
155                     MMixerAddMidiPin(MixerContext, MixerList, MixerData->DeviceId, PinId, TRUE, szPname);
156                 }
157             }
158         }
159 
160         /* move to next datarange */
161         DataRange = (PKSDATARANGE)((ULONG_PTR)DataRange + DataRange->FormatSize);
162 
163         /* alignment assert */
164         ASSERT(((ULONG_PTR)DataRange & 0x7) == 0);
165 
166         /* data ranges are 64-bit aligned */
167         DataRange = (PVOID)(((ULONG_PTR)DataRange + 0x7) & ~0x7);
168     }
169 }
170 
171 VOID
172 MMixerInitializeMidiForFilter(
173     IN PMIXER_CONTEXT MixerContext,
174     IN PMIXER_LIST MixerList,
175     IN LPMIXER_DATA MixerData,
176     IN PTOPOLOGY Topology)
177 {
178     ULONG PinCount, Index;
179     MIXER_STATUS Status;
180     PKSMULTIPLE_ITEM MultipleItem;
181     WCHAR szPname[MAXPNAMELEN];
182 
183     /* get filter pin count */
184     MMixerGetTopologyPinCount(Topology, &PinCount);
185 
186     /* get mixer name */
187     if (MMixerGetDeviceName(MixerContext, szPname, MixerData->hDeviceInterfaceKey) != MM_STATUS_SUCCESS)
188     {
189         /* clear name */
190         szPname[0] = 0;
191     }
192 
193     /* iterate all pins and check for KSDATARANGE_MUSIC support */
194     for(Index = 0; Index < PinCount; Index++)
195     {
196         /* get audio pin data ranges */
197         Status = MMixerGetAudioPinDataRanges(MixerContext, MixerData->hDevice, Index, &MultipleItem);
198 
199         /* check for success */
200         if (Status == MM_STATUS_SUCCESS)
201         {
202             /* check if there is support KSDATARANGE_MUSIC */
203             MMixerCheckFilterPinMidiSupport(MixerContext, MixerList, MixerData, Index, MultipleItem, szPname);
204         }
205     }
206 }
207 
208 MIXER_STATUS
209 MMixerOpenMidiPin(
210     IN PMIXER_CONTEXT MixerContext,
211     IN PMIXER_LIST MixerList,
212     IN ULONG DeviceId,
213     IN ULONG PinId,
214     IN ACCESS_MASK DesiredAccess,
215     IN PIN_CREATE_CALLBACK CreateCallback,
216     IN PVOID Context,
217     OUT PHANDLE PinHandle)
218 {
219     PKSPIN_CONNECT PinConnect;
220     PKSDATAFORMAT DataFormat;
221     LPMIXER_DATA MixerData;
222     NTSTATUS Status;
223     MIXER_STATUS MixerStatus;
224 
225     MixerData = MMixerGetDataByDeviceId(MixerList, DeviceId);
226     if (!MixerData)
227         return MM_STATUS_INVALID_PARAMETER;
228 
229     /* allocate pin connect */
230     PinConnect = MMixerAllocatePinConnect(MixerContext, sizeof(KSDATAFORMAT));
231     if (!PinConnect)
232     {
233         /* no memory */
234         return MM_STATUS_NO_MEMORY;
235     }
236 
237     /* initialize pin connect struct */
238     MMixerInitializePinConnect(PinConnect, PinId);
239 
240     /* get offset to dataformat */
241     DataFormat = (PKSDATAFORMAT) (PinConnect + 1);
242 
243     /* initialize data format */
244     RtlMoveMemory(&DataFormat->MajorFormat, &KSDATAFORMAT_TYPE_MUSIC, sizeof(GUID));
245     RtlMoveMemory(&DataFormat->SubFormat, &KSDATAFORMAT_SUBTYPE_MIDI, sizeof(GUID));
246     RtlMoveMemory(&DataFormat->Specifier, &KSDATAFORMAT_SPECIFIER_NONE, sizeof(GUID));
247 
248     if (CreateCallback)
249     {
250         /* let the callback handle the creation */
251         MixerStatus = CreateCallback(Context, DeviceId, PinId, MixerData->hDevice, PinConnect, DesiredAccess, PinHandle);
252     }
253     else
254     {
255         /* now create the pin */
256         Status = KsCreatePin(MixerData->hDevice, PinConnect, DesiredAccess, PinHandle);
257 
258         /* normalize status */
259         if (Status == STATUS_SUCCESS)
260             MixerStatus = MM_STATUS_SUCCESS;
261         else
262             MixerStatus = MM_STATUS_UNSUCCESSFUL;
263     }
264 
265     /* free create info */
266     MixerContext->Free(PinConnect);
267 
268     /* done */
269     return MixerStatus;
270 }
271 
272 MIXER_STATUS
273 MMixerGetMidiInfoByIndexAndType(
274     IN  PMIXER_LIST MixerList,
275     IN  ULONG DeviceIndex,
276     IN  ULONG bMidiInputType,
277     OUT LPMIDI_INFO *OutMidiInfo)
278 {
279     ULONG Index = 0;
280     PLIST_ENTRY Entry, ListHead;
281     LPMIDI_INFO MidiInfo;
282 
283     if (bMidiInputType)
284         ListHead = &MixerList->MidiInList;
285     else
286         ListHead = &MixerList->MidiOutList;
287 
288     /* get first entry */
289     Entry = ListHead->Flink;
290 
291     while(Entry != ListHead)
292     {
293         MidiInfo = (LPMIDI_INFO)CONTAINING_RECORD(Entry, MIDI_INFO, Entry);
294 
295         if (Index == DeviceIndex)
296         {
297             *OutMidiInfo = MidiInfo;
298             return MM_STATUS_SUCCESS;
299         }
300         Index++;
301         Entry = Entry->Flink;
302     }
303 
304     return MM_STATUS_INVALID_PARAMETER;
305 }
306 
307 MIXER_STATUS
308 MMixerMidiOutCapabilities(
309     IN PMIXER_CONTEXT MixerContext,
310     IN ULONG DeviceIndex,
311     OUT LPMIDIOUTCAPSW Caps)
312 {
313     PMIXER_LIST MixerList;
314     MIXER_STATUS Status;
315     LPMIDI_INFO MidiInfo;
316 
317     /* verify mixer context */
318     Status = MMixerVerifyContext(MixerContext);
319 
320     if (Status != MM_STATUS_SUCCESS)
321     {
322         /* invalid context passed */
323         return Status;
324     }
325 
326     /* grab mixer list */
327     MixerList = (PMIXER_LIST)MixerContext->MixerContext;
328 
329     /* find destination midi */
330     Status = MMixerGetMidiInfoByIndexAndType(MixerList, DeviceIndex, FALSE, &MidiInfo);
331     if (Status != MM_STATUS_SUCCESS)
332     {
333         /* failed to find midi info */
334         return MM_STATUS_UNSUCCESSFUL;
335     }
336 
337     /* copy capabilities */
338     MixerContext->Copy(Caps, &MidiInfo->u.OutCaps, sizeof(MIDIOUTCAPSW));
339 
340     return MM_STATUS_SUCCESS;
341 }
342 
343 MIXER_STATUS
344 MMixerMidiInCapabilities(
345     IN PMIXER_CONTEXT MixerContext,
346     IN ULONG DeviceIndex,
347     OUT LPMIDIINCAPSW Caps)
348 {
349     PMIXER_LIST MixerList;
350     MIXER_STATUS Status;
351     LPMIDI_INFO MidiInfo;
352 
353     /* verify mixer context */
354     Status = MMixerVerifyContext(MixerContext);
355 
356     if (Status != MM_STATUS_SUCCESS)
357     {
358         /* invalid context passed */
359         return Status;
360     }
361 
362     /* grab mixer list */
363     MixerList = (PMIXER_LIST)MixerContext->MixerContext;
364 
365     /* find destination midi */
366     Status = MMixerGetMidiInfoByIndexAndType(MixerList, DeviceIndex, TRUE, &MidiInfo);
367     if (Status != MM_STATUS_SUCCESS)
368     {
369         /* failed to find midi info */
370         return MM_STATUS_UNSUCCESSFUL;
371     }
372 
373     /* copy capabilities */
374     MixerContext->Copy(Caps, &MidiInfo->u.InCaps, sizeof(MIDIINCAPSW));
375 
376     return MM_STATUS_SUCCESS;
377 }
378 
379 MIXER_STATUS
380 MMixerGetMidiDevicePath(
381     IN PMIXER_CONTEXT MixerContext,
382     IN ULONG bMidiIn,
383     IN ULONG DeviceId,
384     OUT LPWSTR * DevicePath)
385 {
386     PMIXER_LIST MixerList;
387     LPMIXER_DATA MixerData;
388     LPMIDI_INFO MidiInfo;
389     SIZE_T Length;
390     MIXER_STATUS Status;
391 
392     /* verify mixer context */
393     Status = MMixerVerifyContext(MixerContext);
394 
395     if (Status != MM_STATUS_SUCCESS)
396     {
397         /* invalid context passed */
398         return Status;
399     }
400 
401     /* grab mixer list */
402     MixerList = (PMIXER_LIST)MixerContext->MixerContext;
403 
404     /* find destination midi */
405     Status = MMixerGetMidiInfoByIndexAndType(MixerList, DeviceId, bMidiIn, &MidiInfo);
406     if (Status != MM_STATUS_SUCCESS)
407     {
408         /* failed to find midi info */
409         return MM_STATUS_INVALID_PARAMETER;
410     }
411 
412     /* get associated device id */
413     MixerData = MMixerGetDataByDeviceId(MixerList, MidiInfo->DeviceId);
414     if (!MixerData)
415         return MM_STATUS_INVALID_PARAMETER;
416 
417     /* calculate length */
418     Length = wcslen(MixerData->DeviceName)+1;
419 
420     /* allocate destination buffer */
421     *DevicePath = MixerContext->Alloc(Length * sizeof(WCHAR));
422 
423     if (!*DevicePath)
424     {
425         /* no memory */
426         return MM_STATUS_NO_MEMORY;
427     }
428 
429     /* copy device path */
430     MixerContext->Copy(*DevicePath, MixerData->DeviceName, Length * sizeof(WCHAR));
431 
432     /* done */
433     return MM_STATUS_SUCCESS;
434 }
435 
436 MIXER_STATUS
437 MMixerSetMidiStatus(
438     IN PMIXER_CONTEXT MixerContext,
439     IN HANDLE PinHandle,
440     IN KSSTATE State)
441 {
442     KSPROPERTY Property;
443     ULONG Length;
444 
445     /* setup property request */
446     Property.Set = KSPROPSETID_Connection;
447     Property.Id = KSPROPERTY_CONNECTION_STATE;
448     Property.Flags = KSPROPERTY_TYPE_SET;
449 
450     return MixerContext->Control(PinHandle, IOCTL_KS_PROPERTY, &Property, sizeof(KSPROPERTY), &State, sizeof(KSSTATE), &Length);
451 }
452 
453 MIXER_STATUS
454 MMixerOpenMidi(
455     IN PMIXER_CONTEXT MixerContext,
456     IN ULONG DeviceIndex,
457     IN ULONG bMidiIn,
458     IN PIN_CREATE_CALLBACK CreateCallback,
459     IN PVOID Context,
460     OUT PHANDLE PinHandle)
461 {
462     PMIXER_LIST MixerList;
463     MIXER_STATUS Status;
464     LPMIDI_INFO MidiInfo;
465     ACCESS_MASK DesiredAccess = 0;
466 
467     /* verify mixer context */
468     Status = MMixerVerifyContext(MixerContext);
469 
470     if (Status != MM_STATUS_SUCCESS)
471     {
472         /* invalid context passed */
473         return Status;
474     }
475 
476     /* grab mixer list */
477     MixerList = (PMIXER_LIST)MixerContext->MixerContext;
478 
479     /* find destination midi */
480     Status = MMixerGetMidiInfoByIndexAndType(MixerList, DeviceIndex, bMidiIn, &MidiInfo);
481     if (Status != MM_STATUS_SUCCESS)
482     {
483         /* failed to find midi info */
484         return MM_STATUS_INVALID_PARAMETER;
485     }
486 
487     /* get desired access */
488     if (bMidiIn)
489     {
490         DesiredAccess |= GENERIC_READ;
491     }
492      else
493     {
494         DesiredAccess |= GENERIC_WRITE;
495     }
496 
497     /* now try open the pin */
498     return MMixerOpenMidiPin(MixerContext, MixerList, MidiInfo->DeviceId, MidiInfo->PinId, DesiredAccess, CreateCallback, Context, PinHandle);
499 }
500 
501 ULONG
502 MMixerGetMidiInCount(
503     IN PMIXER_CONTEXT MixerContext)
504 {
505     PMIXER_LIST MixerList;
506     MIXER_STATUS Status;
507 
508      /* verify mixer context */
509     Status = MMixerVerifyContext(MixerContext);
510 
511     if (Status != MM_STATUS_SUCCESS)
512     {
513         /* invalid context passed */
514         return Status;
515     }
516 
517     /* grab mixer list */
518     MixerList = (PMIXER_LIST)MixerContext->MixerContext;
519 
520     return MixerList->MidiInListCount;
521 }
522 
523 ULONG
524 MMixerGetMidiOutCount(
525     IN PMIXER_CONTEXT MixerContext)
526 {
527     PMIXER_LIST MixerList;
528     MIXER_STATUS Status;
529 
530      /* verify mixer context */
531     Status = MMixerVerifyContext(MixerContext);
532 
533     if (Status != MM_STATUS_SUCCESS)
534     {
535         /* invalid context passed */
536         return Status;
537     }
538 
539     /* grab mixer list */
540     MixerList = (PMIXER_LIST)MixerContext->MixerContext;
541 
542     return MixerList->MidiOutListCount;
543 }
544