ReactOS 0.4.15-dev-6712-g46b4b55
sup.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Kernel Streaming
4 * FILE: lib/drivers/sound/mmixer/sup.c
5 * PURPOSE: Mixer Support Functions
6 * PROGRAMMER: Johannes Anderwald
7 */
8
9#include "precomp.h"
10
11#define YDEBUG
12#include <debug.h>
13
14const GUID KSNODETYPE_SUM = {0xDA441A60L, 0xC556, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
15const GUID KSNODETYPE_DAC = {0x507AE360L, 0xC554, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
16const GUID KSNODETYPE_ADC = {0x4D837FE0L, 0xC555, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
17const GUID KSNODETYPE_AGC = {0xE88C9BA0L, 0xC557, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
18const GUID KSNODETYPE_LOUDNESS = {0x41887440L, 0xC558, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
19const GUID KSNODETYPE_MUTE = {0x02B223C0L, 0xC557, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
20const GUID KSNODETYPE_TONE = {0x7607E580L, 0xC557, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
21const GUID KSNODETYPE_VOLUME = {0x3A5ACC00L, 0xC557, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
22const GUID KSNODETYPE_PEAKMETER = {0xa085651e, 0x5f0d, 0x4b36, {0xa8, 0x69, 0xd1, 0x95, 0xd6, 0xab, 0x4b, 0x9e}};
23const GUID KSNODETYPE_MUX = {0x2CEAF780, 0xC556, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
24const GUID KSNODETYPE_STEREO_WIDE = {0xA9E69800L, 0xC558, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
25const GUID KSNODETYPE_CHORUS = {0x20173F20L, 0xC559, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
26const GUID KSNODETYPE_REVERB = {0xEF0328E0L, 0xC558, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
27const GUID KSNODETYPE_SUPERMIX = {0xE573ADC0L, 0xC555, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}};
28
29const GUID KSPROPSETID_Audio = {0x45FFAAA0L, 0x6E1B, 0x11D0, {0xBC, 0xF2, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}};
30const GUID KSPROPSETID_Pin = {0x8C134960L, 0x51AD, 0x11CF, {0x87, 0x8A, 0x94, 0xF8, 0x01, 0xC1, 0x00, 0x00}};
31const GUID KSPROPSETID_General = {0x1464EDA5L, 0x6A8F, 0x11D1, {0x9A, 0xA7, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
32const GUID KSPROPSETID_Topology = {0x720D4AC0L, 0x7533, 0x11D0, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
33const GUID KSEVENTSETID_AudioControlChange = {0xE85E9698L, 0xFA2F, 0x11D1, {0x95, 0xBD, 0x00, 0xC0, 0x4F, 0xB9, 0x25, 0xD3}};
34
35const GUID KSDATAFORMAT_TYPE_MUSIC = {0xE725D360L, 0x62CC, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
36const GUID KSDATAFORMAT_SUBTYPE_MIDI = {0x1D262760L, 0xE957, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
37const GUID KSDATAFORMAT_SPECIFIER_NONE = {0x0F6417D6L, 0xC318, 0x11D0, {0xA4, 0x3F, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
38
39
43{
46
51
54
55 return MM_STATUS_SUCCESS;
56}
57
60 IN LPMIXER_INFO MixerInfo,
61 IN ULONG NodeID)
62{
63 PLIST_ENTRY Entry, ControlEntry;
64 LPMIXERLINE_EXT MixerLineSrc;
65 LPMIXERCONTROL_EXT MixerControl;
66
67 /* get first entry */
68 Entry = MixerInfo->LineList.Flink;
69
70 while(Entry != &MixerInfo->LineList)
71 {
73
74 ControlEntry = MixerLineSrc->ControlsList.Flink;
75 while(ControlEntry != &MixerLineSrc->ControlsList)
76 {
77 MixerControl = (LPMIXERCONTROL_EXT)CONTAINING_RECORD(ControlEntry, MIXERCONTROL_EXT, Entry);
78 if (MixerControl->NodeID == NodeID)
79 {
80 return MixerLineSrc;
81 }
82 ControlEntry = ControlEntry->Flink;
83 }
84 Entry = Entry->Flink;
85 }
86
87 return NULL;
88}
89
90VOID
92 IN ULONG LogicalPinArrayCount,
93 IN PULONG LogicalPinArray,
94 OUT PULONG PinOffset)
95{
97 ULONG LowestId = 0;
98
99 for(Index = 1; Index < LogicalPinArrayCount; Index++)
100 {
101 if (LogicalPinArray[Index] != MAXULONG)
102 {
103 /* sanity check: logical pin id must be unique */
104 ASSERT(LogicalPinArray[Index] != LogicalPinArray[LowestId]);
105 }
106
107 if (LogicalPinArray[Index] < LogicalPinArray[LowestId])
108 LowestId = Index;
109 }
110
111 /* store result */
112 *PinOffset = LowestId;
113}
114
115VOID
118 IN LPMIXER_INFO MixerInfo)
119{
120 /* UNIMPLEMENTED;
121 * FIXME
122 * free all lines
123 */
124
125 MixerContext->Free((PVOID)MixerInfo);
126}
127
128
132 IN HANDLE hDevice)
133{
134 LPMIXER_DATA MixerData;
136 PMIXER_LIST MixerList;
137
138 /* get mixer list */
140
141 if (!MixerList->MixerDataCount)
142 return NULL;
143
144 Entry = MixerList->MixerData.Flink;
145
146 while(Entry != &MixerList->MixerData)
147 {
149
150 if (MixerData->hDevice == hDevice)
151 return MixerData;
152
153 /* move to next mixer entry */
154 Entry = Entry->Flink;
155 }
156 return NULL;
157}
158
159
163 IN ULONG MixerIndex)
164{
165 LPMIXER_INFO MixerInfo;
167 PMIXER_LIST MixerList;
168 ULONG Index = 0;
169
170 /* get mixer list */
172
173 if (!MixerList->MixerListCount)
174 return NULL;
175
176 Entry = MixerList->MixerList.Flink;
177
178 while(Entry != &MixerList->MixerList)
179 {
181
182 if (Index == MixerIndex)
183 return MixerInfo;
184
185 /* move to next mixer entry */
186 Index++;
187 Entry = Entry->Flink;
188 }
189
190 return NULL;
191}
192
195 IN PMIXER_LIST MixerList,
196 IN LPWSTR MixerName,
197 OUT LPMIXER_INFO *OutMixerInfo)
198{
199 LPMIXER_INFO MixerInfo;
201
202 Entry = MixerList->MixerList.Flink;
203 while(Entry != &MixerList->MixerList)
204 {
206
207 DPRINT1("MixerName %S MixerName %S\n", MixerInfo->MixCaps.szPname, MixerName);
208 if (wcsicmp(MixerInfo->MixCaps.szPname, MixerName) == 0)
209 {
210 *OutMixerInfo = MixerInfo;
211 return MM_STATUS_SUCCESS;
212 }
213 /* move to next mixer entry */
214 Entry = Entry->Flink;
215 }
216
218}
219
222 LPMIXER_INFO MixerInfo,
223 DWORD dwLineID)
224{
226 LPMIXERLINE_EXT MixerLineSrc;
227
228 /* get first entry */
229 Entry = MixerInfo->LineList.Flink;
230
231 while(Entry != &MixerInfo->LineList)
232 {
234 DPRINT("dwLineID %x dwLineID %x MixerLineSrc %p\n", MixerLineSrc->Line.dwLineID, dwLineID, MixerLineSrc);
235 if (MixerLineSrc->Line.dwLineID == dwLineID)
236 return MixerLineSrc;
237
238 Entry = Entry->Flink;
239 }
240
241 return NULL;
242}
243
244LPGUID
246 IN PKSMULTIPLE_ITEM MultipleItem,
247 IN ULONG Index)
248{
250
251 ASSERT(Index < MultipleItem->Count);
252
253 NodeType = (LPGUID)(MultipleItem + 1);
254 return &NodeType[Index];
255}
256
259 LPMIXER_INFO MixerInfo,
260 DWORD dwComponentType)
261{
263 LPMIXERLINE_EXT MixerLineSrc;
264
265 /* get first entry */
266 Entry = MixerInfo->LineList.Flink;
267
268 while(Entry != &MixerInfo->LineList)
269 {
271 if (MixerLineSrc->Line.dwComponentType == dwComponentType)
272 return MixerLineSrc;
273
274 Entry = Entry->Flink;
275 }
276
277 return NULL;
278}
279
282 LPMIXER_INFO MixerInfo,
283 DWORD dwControlID,
284 LPMIXERLINE_EXT *OutMixerLine,
285 LPMIXERCONTROL_EXT *OutMixerControl,
286 PULONG NodeId)
287{
288 PLIST_ENTRY Entry, ControlEntry;
289 LPMIXERLINE_EXT MixerLineSrc;
290 LPMIXERCONTROL_EXT MixerControl;
291
292 /* get first entry */
293 Entry = MixerInfo->LineList.Flink;
294
295 while(Entry != &MixerInfo->LineList)
296 {
298
299 ControlEntry = MixerLineSrc->ControlsList.Flink;
300 while(ControlEntry != &MixerLineSrc->ControlsList)
301 {
302 MixerControl = (LPMIXERCONTROL_EXT)CONTAINING_RECORD(ControlEntry, MIXERCONTROL_EXT, Entry);
303 if (MixerControl->Control.dwControlID == dwControlID)
304 {
305 if (OutMixerLine)
306 *OutMixerLine = MixerLineSrc;
307 if (OutMixerControl)
308 *OutMixerControl = MixerControl;
309 if (NodeId)
310 *NodeId = MixerControl->NodeID;
311 return MM_STATUS_SUCCESS;
312 }
313 ControlEntry = ControlEntry->Flink;
314 }
315 Entry = Entry->Flink;
316 }
317
319}
320
321ULONG
323 LPMIXERVOLUME_DATA VolumeData,
324 LONG Value)
325{
326 ULONG Index;
327
328 for(Index = 0; Index < VolumeData->ValuesCount; Index++)
329 {
330 if (VolumeData->Values[Index] > Value)
331 {
332 return VolumeData->InputSteppingDelta * Index;
333 }
334 }
335 return VolumeData->InputSteppingDelta * (VolumeData->ValuesCount-1);
336}
337
338VOID
341 IN LPMIXER_INFO MixerInfo,
343 IN ULONG Value)
344{
347
348 /* enumerate list and perform notification */
349 Entry = MixerInfo->EventList.Flink;
350 while(Entry != &MixerInfo->EventList)
351 {
352 /* get notification entry offset */
354
355 if (NotificationEntry->MixerEventRoutine)
356 {
357 /* now perform the callback */
358 NotificationEntry->MixerEventRoutine(NotificationEntry->MixerEventContext, (HANDLE)MixerInfo, NotificationType, Value);
359 }
360
361 /* move to next notification entry */
362 Entry = Entry->Flink;
363 }
364}
365
369 IN LPMIXER_INFO MixerInfo,
370 IN LPMIXERCONTROL_EXT MixerControl,
371 IN ULONG dwLineID,
372 IN LPMIXERCONTROLDETAILS MixerControlDetails,
373 IN ULONG bSet)
374{
376 LONG Value;
378
379 if (MixerControlDetails->cbDetails != sizeof(MIXERCONTROLDETAILS_BOOLEAN))
381
382 /* get input */
383 Input = (LPMIXERCONTROLDETAILS_BOOLEAN)MixerControlDetails->paDetails;
384
385 /* FIXME SEH */
386 if (bSet)
387 Value = Input->fValue;
388
389 /* set control details */
390 Status = MMixerSetGetControlDetails(MixerContext, MixerControl->hDevice, MixerControl->NodeID, bSet, KSPROPERTY_AUDIO_MUTE, 0, &Value);
391
393 return Status;
394
395 /* FIXME SEH */
396 if (!bSet)
397 {
398 Input->fValue = Value;
399 return Status;
400 }
401 else
402 {
403 /* notify wdmaud clients MM_MIXM_LINE_CHANGE dwLineID */
405 }
406
407 return Status;
408}
409
413 IN LPMIXER_INFO MixerInfo,
414 IN ULONG NodeId,
415 IN ULONG bSet,
416 IN ULONG Flags,
417 IN LPMIXERCONTROL_EXT MixerControl,
418 IN LPMIXERCONTROLDETAILS MixerControlDetails,
419 IN LPMIXERLINE_EXT MixerLine)
420{
422 PULONG LogicalNodes, ConnectedNodes;
423 ULONG LogicalNodesCount, ConnectedNodesCount, Index, CurLogicalPinOffset, BytesReturned, OldLogicalPinOffset;
424 LPMIXER_DATA MixerData;
427 LPMIXERLINE_EXT SourceLine;
429
430 DPRINT("MixerControlDetails %p\n", MixerControlDetails);
431 DPRINT("bSet %lx\n", bSet);
432 DPRINT("Flags %lx\n", Flags);
433 DPRINT("NodeId %lu\n", MixerControl->NodeID);
434 DPRINT("MixerControlDetails dwControlID %lu\n", MixerControlDetails->dwControlID);
435 DPRINT("MixerControlDetails cChannels %lu\n", MixerControlDetails->cChannels);
436 DPRINT("MixerControlDetails cMultipleItems %lu\n", MixerControlDetails->cMultipleItems);
437 DPRINT("MixerControlDetails cbDetails %lu\n", MixerControlDetails->cbDetails);
438 DPRINT("MixerControlDetails paDetails %p\n", MixerControlDetails->paDetails);
439
440 if (MixerControl->Control.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
441 {
442 /* control acts uniform */
443 if (MixerControlDetails->cChannels != 1)
444 {
445 /* expected 1 channel */
446 DPRINT1("Expected 1 channel but got %lu\n", MixerControlDetails->cChannels);
448 }
449 }
450
451 /* check if multiple items match */
452 if (MixerControlDetails->cMultipleItems != MixerControl->Control.cMultipleItems)
453 {
454 DPRINT1("MultipleItems mismatch %lu expected %lu\n", MixerControlDetails->cMultipleItems, MixerControl->Control.cMultipleItems);
456 }
457
458 if (bSet)
459 {
461 {
462 /* tell me when this is hit */
463 ASSERT(FALSE);
464 }
466 {
467 /* sanity check */
468 ASSERT(bSet == TRUE);
469 ASSERT(MixerControlDetails->cbDetails == sizeof(MIXERCONTROLDETAILS_BOOLEAN));
470
471 Values = (LPMIXERCONTROLDETAILS_BOOLEAN)MixerControlDetails->paDetails;
472 CurLogicalPinOffset = MAXULONG;
473 for(Index = 0; Index < MixerControlDetails->cMultipleItems; Index++)
474 {
475 if (Values[Index].fValue)
476 {
477 /* mux can only activate one line at a time */
478 ASSERT(CurLogicalPinOffset == MAXULONG);
479 CurLogicalPinOffset = Index;
480 }
481 }
482
483 /* setup request */
484 Request.NodeId = NodeId;
485 Request.Reserved = 0;
488 Request.Property.Set = KSPROPSETID_Audio;
489
490 /* perform getting source */
491 Status = MixerContext->Control(MixerControl->hDevice, IOCTL_KS_PROPERTY, (PVOID)&Request, sizeof(KSNODEPROPERTY), &OldLogicalPinOffset, sizeof(ULONG), &BytesReturned);
493 {
494 /* failed to get source */
495 return Status;
496 }
497
498 DPRINT("OldLogicalPinOffset %lu CurLogicalPinOffset %lu\n", OldLogicalPinOffset, CurLogicalPinOffset);
499
500 if (OldLogicalPinOffset == CurLogicalPinOffset)
501 {
502 /* cannot be unselected */
504 }
505
506 /* perform setting source */
508 Status = MixerContext->Control(MixerControl->hDevice, IOCTL_KS_PROPERTY, (PVOID)&Request, sizeof(KSNODEPROPERTY), &CurLogicalPinOffset, sizeof(ULONG), &BytesReturned);
510 {
511 /* failed to set source */
512 return Status;
513 }
514
515 /* notify control change */
516 MMixerNotifyControlChange(MixerContext, MixerInfo, MM_MIXM_CONTROL_CHANGE, MixerControl->Control.dwControlID );
517
518 return Status;
519 }
520 }
521 else
522 {
524 {
525 /* setup request */
526 Request.NodeId = NodeId;
527 Request.Reserved = 0;
530 Request.Property.Set = KSPROPSETID_Audio;
531
532 /* perform getting source */
533 Status = MixerContext->Control(MixerControl->hDevice, IOCTL_KS_PROPERTY, (PVOID)&Request, sizeof(KSNODEPROPERTY), &OldLogicalPinOffset, sizeof(ULONG), &BytesReturned);
535 {
536 /* failed to get source */
537 return Status;
538 }
539
540 /* gets the corresponding mixer data */
541 MixerData = MMixerGetMixerDataByDeviceHandle(MixerContext, MixerControl->hDevice);
542
543 /* sanity check */
544 ASSERT(MixerData);
545 ASSERT(MixerData->Topology);
546 ASSERT(MixerData->MixerInfo == MixerInfo);
547
548 /* now allocate logical pin array */
549 Status = MMixerAllocateTopologyNodeArray(MixerContext, MixerData->Topology, &LogicalNodes);
551 {
552 /* no memory */
553 return MM_STATUS_NO_MEMORY;
554 }
555
556 /* get logical pin nodes */
557 MMixerGetConnectedFromLogicalTopologyPins(MixerData->Topology, MixerControl->NodeID, &LogicalNodesCount, LogicalNodes);
558
559 /* sanity check */
560 ASSERT(LogicalNodesCount == MixerControlDetails->cMultipleItems);
561 ASSERT(LogicalNodesCount == MixerControl->Control.Metrics.dwReserved[0]);
562
563 Values = (LPMIXERCONTROLDETAILS_BOOLEAN)MixerControlDetails->paDetails;
564 for(Index = 0; Index < LogicalNodesCount; Index++)
565 {
566 /* getting logical pin offset */
567 MMixerGetLowestLogicalTopologyPinOffsetFromArray(LogicalNodesCount, LogicalNodes, &CurLogicalPinOffset);
568
569 if (CurLogicalPinOffset == OldLogicalPinOffset)
570 {
571 /* mark index as active */
572 Values[Index].fValue = TRUE;
573 }
574 else
575 {
576 /* index not active */
577 Values[Index].fValue = FALSE;
578 }
579
580 /* mark offset as consumed */
581 LogicalNodes[CurLogicalPinOffset] = MAXULONG;
582 }
583
584 /* cleanup */
585 MixerContext->Free(LogicalNodes);
586
587 /* done */
588 return MM_STATUS_SUCCESS;
589 }
591 {
592 /* sanity check */
593 ASSERT(bSet == FALSE);
594
595 /* gets the corresponding mixer data */
596 MixerData = MMixerGetMixerDataByDeviceHandle(MixerContext, MixerControl->hDevice);
597
598 /* sanity check */
599 ASSERT(MixerData);
600 ASSERT(MixerData->Topology);
601 ASSERT(MixerData->MixerInfo == MixerInfo);
602
603 /* now allocate logical pin array */
604 Status = MMixerAllocateTopologyNodeArray(MixerContext, MixerData->Topology, &LogicalNodes);
606 {
607 /* no memory */
608 return MM_STATUS_NO_MEMORY;
609 }
610
611 /* allocate connected node array */
612 Status = MMixerAllocateTopologyNodeArray(MixerContext, MixerData->Topology, &ConnectedNodes);
614 {
615 /* no memory */
616 MixerContext->Free(LogicalNodes);
617 return MM_STATUS_NO_MEMORY;
618 }
619
620 /* get logical pin nodes */
621 MMixerGetConnectedFromLogicalTopologyPins(MixerData->Topology, MixerControl->NodeID, &LogicalNodesCount, LogicalNodes);
622
623 /* get connected nodes */
624 MMixerGetNextNodesFromNodeIndex(MixerContext, MixerData->Topology, MixerControl->NodeID, TRUE, &ConnectedNodesCount, ConnectedNodes);
625
626 /* sanity check */
627 ASSERT(ConnectedNodesCount == LogicalNodesCount);
628 ASSERT(ConnectedNodesCount == MixerControlDetails->cMultipleItems);
629 ASSERT(ConnectedNodesCount == MixerControl->Control.Metrics.dwReserved[0]);
630
631 ListText = (LPMIXERCONTROLDETAILS_LISTTEXTW)MixerControlDetails->paDetails;
632
633 for(Index = 0; Index < ConnectedNodesCount; Index++)
634 {
635 /* getting logical pin offset */
636 MMixerGetLowestLogicalTopologyPinOffsetFromArray(LogicalNodesCount, LogicalNodes, &CurLogicalPinOffset);
637
638 /* get mixer line with that node */
639 SourceLine = MMixerGetMixerLineContainingNodeId(MixerInfo, ConnectedNodes[CurLogicalPinOffset]);
640
641 /* sanity check */
642 ASSERT(SourceLine);
643
644 DPRINT1("PinOffset %lu LogicalPin %lu NodeId %lu LineName %S\n", CurLogicalPinOffset, LogicalNodes[CurLogicalPinOffset], ConnectedNodes[CurLogicalPinOffset], SourceLine->Line.szName);
645
646 /* copy details */
647 ListText[Index].dwParam1 = SourceLine->Line.dwLineID;
648 ListText[Index].dwParam2 = SourceLine->Line.dwComponentType;
649 MixerContext->Copy(ListText[Index].szName, SourceLine->Line.szName, (wcslen(SourceLine->Line.szName) + 1) * sizeof(WCHAR));
650
651 /* mark offset as consumed */
652 LogicalNodes[CurLogicalPinOffset] = MAXULONG;
653 }
654
655 /* cleanup */
656 MixerContext->Free(LogicalNodes);
657 MixerContext->Free(ConnectedNodes);
658
659 /* done */
660 return MM_STATUS_SUCCESS;
661 }
662 }
663
665}
666
670 IN LPMIXER_INFO MixerInfo,
671 IN ULONG NodeId,
672 IN ULONG bSet,
673 LPMIXERCONTROL_EXT MixerControl,
674 IN LPMIXERCONTROLDETAILS MixerControlDetails,
675 LPMIXERLINE_EXT MixerLine)
676{
678 LONG Value;
679 ULONG Index, Channel = 0;
680 ULONG dwValue;
682 LPMIXERVOLUME_DATA VolumeData;
683
684 if (MixerControlDetails->cbDetails != sizeof(MIXERCONTROLDETAILS_SIGNED))
686
687 VolumeData = (LPMIXERVOLUME_DATA)MixerControl->ExtraData;
688 if (!VolumeData)
690
691 /* get input */
692 Input = (LPMIXERCONTROLDETAILS_UNSIGNED)MixerControlDetails->paDetails;
693 if (!Input)
694 return MM_STATUS_UNSUCCESSFUL; /* to prevent dereferencing NULL */
695
696 if (bSet)
697 {
698 /* FIXME SEH */
699 Value = Input->dwValue;
700 Index = Value / VolumeData->InputSteppingDelta;
701
702 if (Index >= VolumeData->ValuesCount)
703 {
704 DPRINT1("Index %u out of bounds %u \n", Index, VolumeData->ValuesCount);
706 }
707
708 Value = VolumeData->Values[Index];
709 }
710
711 /* set control details */
712 if (bSet)
713 {
714 /* TODO */
717 }
718 else
719 {
721 }
722
723 if (!bSet)
724 {
725 dwValue = MMixerGetVolumeControlIndex(VolumeData, (LONG)Value);
726 /* FIXME SEH */
727 Input->dwValue = dwValue;
728 }
729 else
730 {
731 /* notify clients of a line change MM_MIXM_CONTROL_CHANGE with MixerControl->dwControlID */
733 }
734 return Status;
735}
736
739 IN PMIXER_LIST MixerList,
740 IN ULONG DeviceId)
741{
743 LPMIXER_DATA MixerData;
744
745 Entry = MixerList->MixerData.Flink;
746 while(Entry != &MixerList->MixerData)
747 {
749 if (MixerData->DeviceId == DeviceId)
750 {
751 return MixerData;
752 }
753 Entry = Entry->Flink;
754 }
755 return NULL;
756}
757
760 IN PMIXER_LIST MixerList,
762{
764 LPMIXER_DATA MixerData;
765
766 Entry = MixerList->MixerData.Flink;
767 while(Entry != &MixerList->MixerData)
768 {
770 if (wcsicmp(&DeviceName[2], &MixerData->DeviceName[2]) == 0)
771 {
772 /* found entry */
773 return MixerData;
774 }
775 Entry = Entry->Flink;
776 }
777 return NULL;
778}
779
783 IN PMIXER_LIST MixerList,
784 IN ULONG DeviceId,
786 IN HANDLE hDevice,
787 IN HANDLE hKey)
788{
789 LPMIXER_DATA MixerData;
790
791 MixerData = (LPMIXER_DATA)MixerContext->Alloc(sizeof(MIXER_DATA));
792 if (!MixerData)
793 return MM_STATUS_NO_MEMORY;
794
795 MixerData->DeviceId = DeviceId;
796 MixerData->DeviceName = DeviceName;
797 MixerData->hDevice = hDevice;
798 MixerData->hDeviceInterfaceKey = hKey;
799 MixerData->Topology = NULL;
800
801 InsertTailList(&MixerList->MixerData, &MixerData->Entry);
802 MixerList->MixerDataCount++;
803 return MM_STATUS_SUCCESS;
804}
805
810 OUT LPWSTR OutDeviceName)
811{
817 ULONG ResultLength, KeyType;
818 HANDLE hMediaKey, hGuidKey;
820
821 /* prepare property */
825
826 /* try get component id */
828
830 {
831 Status = MixerContext->OpenKey(NULL, L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\MediaCategories", KEY_READ, &hMediaKey);
833 {
835 Status = MixerContext->OpenKey(hMediaKey, GuidString.Buffer, KEY_READ, &hGuidKey);
838 {
839 Status = MixerContext->QueryKeyValue(hGuidKey, L"Name", (PVOID*)&DeviceName, &ResultLength, &KeyType);
841 {
842 MixerContext->Copy(OutDeviceName, DeviceName, min(ResultLength, (MAXPNAMELEN-1)*2));
844 }
845
846 MixerContext->CloseKey(hGuidKey);
847 }
848 MixerContext->CloseKey(hMediaKey);
849 }
850 }
851 return Status;
852}
853
858 IN HANDLE hKey)
859{
860 LPWSTR Name;
861 HANDLE hTemp;
863 ULONG Type;
865
866 Status = MixerContext->QueryKeyValue(hKey, L"FriendlyName", (PVOID*)&Name, &Length, &Type);
868 {
869 /* copy device name */
871
872 /* make sure its null terminated */
873 DeviceName[MAXPNAMELEN-1] = L'\0';
874
875 /* free device name */
877
878 /* done */
879 return Status;
880 }
881
882 Status = MixerContext->OpenKey(hKey, L"Device Parameters", KEY_READ, &hTemp);
884 return Status;
885
886 Status = MixerContext->QueryKeyValue(hTemp, L"FriendlyName", (PVOID*)&Name, &Length, &Type);
888 {
889 /* copy device name */
891
892 /* make sure its null terminated */
893 DeviceName[MAXPNAMELEN-1] = L'\0';
894
895 /* free device name */
897 }
898
899 MixerContext->CloseKey(hTemp);
900 return Status;
901}
902
903VOID
905 IN OUT PKSPIN_CONNECT PinConnect,
906 IN ULONG PinId)
907{
908 PinConnect->Interface.Set = KSINTERFACESETID_Standard;
909 PinConnect->Interface.Id = KSINTERFACE_STANDARD_STREAMING;
910 PinConnect->Interface.Flags = 0;
911 PinConnect->Medium.Set = KSMEDIUMSETID_Standard;
912 PinConnect->Medium.Id = KSMEDIUM_TYPE_ANYINSTANCE;
913 PinConnect->Medium.Flags = 0;
914 PinConnect->PinToHandle = NULL;
915 PinConnect->PinId = PinId;
916 PinConnect->Priority.PriorityClass = KSPRIORITY_NORMAL;
917 PinConnect->Priority.PrioritySubClass = 1;
918}
NodeType
Definition: Node.h:6
Type
Definition: Type.h:7
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 ACPI_STATUS const char UINT32 ACPI_STATUS const char UINT32 const char const char UINT32 ComponentId
Definition: acpixf.h:1281
struct NameRec_ * Name
Definition: cdprocs.h:460
#define DPRINT1
Definition: precomp.h:8
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define wcsicmp
Definition: compat.h:15
MIXER_CONTEXT MixerContext
Definition: mmixer.c:41
#define NodeType(P)
Definition: nodetype.h:51
#define KSPROPERTY_TYPE_SET
Definition: dmksctrl.h:43
#define KSPROPERTY_TYPE_TOPOLOGY
Definition: dmksctrl.h:53
#define KSPROPERTY_TYPE_GET
Definition: dmksctrl.h:42
#define InsertTailList(ListHead, Entry)
unsigned long DWORD
Definition: ntddk_ex.h:95
FxAutoRegKey hKey
Status
Definition: gdiplustypes.h:25
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
NTSYSAPI NTSTATUS WINAPI RtlStringFromGUID(REFGUID, PUNICODE_STRING)
#define KSPRIORITY_NORMAL
Definition: ks.h:1386
#define KSMEDIUM_TYPE_ANYINSTANCE
Definition: ks.h:301
#define KSMEDIUMSETID_Standard
Definition: ks.h:306
#define IOCTL_KS_PROPERTY
Definition: ks.h:127
@ KSINTERFACE_STANDARD_STREAMING
Definition: ks.h:283
#define KSINTERFACESETID_Standard
Definition: ks.h:280
@ KSPROPERTY_GENERAL_COMPONENTID
Definition: ks.h:447
@ KSPROPERTY_AUDIO_VOLUMELEVEL
Definition: ksmedia.h:1057
@ KSPROPERTY_AUDIO_MUTE
Definition: ksmedia.h:1066
@ KSPROPERTY_AUDIO_MUX_SOURCE
Definition: ksmedia.h:1065
if(dx< 0)
Definition: linetemp.h:194
MIXER_STATUS
Definition: mmixer.h:4
@ MM_STATUS_NOT_IMPLEMENTED
Definition: mmixer.h:7
@ MM_STATUS_UNSUCCESSFUL
Definition: mmixer.h:11
@ MM_STATUS_INVALID_PARAMETER
Definition: mmixer.h:10
@ MM_STATUS_NO_MEMORY
Definition: mmixer.h:12
@ MM_STATUS_SUCCESS
Definition: mmixer.h:5
#define MIXERCONTROL_CONTROLF_UNIFORM
Definition: mmsystem.h:350
#define MIXER_SETCONTROLDETAILSF_VALUE
Definition: mmsystem.h:415
struct tMIXERCONTROLDETAILS_BOOLEAN * LPMIXERCONTROLDETAILS_BOOLEAN
#define MIXER_GETCONTROLDETAILSF_VALUE
Definition: mmsystem.h:412
#define MIXER_GETCONTROLDETAILSF_QUERYMASK
Definition: mmsystem.h:414
#define MM_MIXM_CONTROL_CHANGE
Definition: mmsystem.h:83
#define MIXER_SETCONTROLDETAILSF_CUSTOM
Definition: mmsystem.h:416
#define MIXER_SETCONTROLDETAILSF_QUERYMASK
Definition: mmsystem.h:417
#define MIXER_GETCONTROLDETAILSF_LISTTEXT
Definition: mmsystem.h:413
#define MM_MIXM_LINE_CHANGE
Definition: mmsystem.h:82
struct tagMIXERCONTROLDETAILS_LISTTEXTW * LPMIXERCONTROLDETAILS_LISTTEXTW
#define MAXPNAMELEN
Definition: mmsystem.h:24
struct tMIXERCONTROLDETAILS_UNSIGNED * LPMIXERCONTROLDETAILS_UNSIGNED
#define ASSERT(a)
Definition: mode.c:44
static PWSTR GuidString
Definition: apphelp.c:93
HMIXER hMixer
Definition: test.c:10
#define min(a, b)
Definition: monoChain.cc:55
int Count
Definition: noreturn.cpp:7
#define KEY_READ
Definition: nt_native.h:1023
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
#define L(x)
Definition: ntvdm.h:50
long LONG
Definition: pedump.c:60
static const WCHAR szName[]
Definition: powrprof.c:45
GUID * LPGUID
Definition: guiddef.h:81
@ Input
Definition: arc.h:84
MIXER_STATUS MMixerSetGetControlDetails(IN PMIXER_CONTEXT MixerContext, IN HANDLE hMixer, IN ULONG NodeId, IN ULONG bSet, IN ULONG PropertyId, IN ULONG Channel, IN PLONG InputValue)
Definition: filter.c:219
struct MIXERLINE_EXT * LPMIXERLINE_EXT
struct EVENT_NOTIFICATION_ENTRY * PEVENT_NOTIFICATION_ENTRY
struct MIXERVOLUME_DATA * LPMIXERVOLUME_DATA
struct MIXER_DATA * LPMIXER_DATA
struct MIXERCONTROL_EXT * LPMIXERCONTROL_EXT
struct MIXER_LIST * PMIXER_LIST
VOID MMixerGetConnectedFromLogicalTopologyPins(IN PTOPOLOGY Topology, IN ULONG NodeIndex, OUT PULONG OutPinCount, OUT PULONG OutPins)
Definition: topology.c:1165
MIXER_STATUS MMixerAllocateTopologyNodeArray(IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, OUT PULONG *OutPins)
Definition: topology.c:1052
VOID MMixerGetNextNodesFromNodeIndex(IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, IN ULONG NodeIndex, IN ULONG bUpStream, OUT PULONG OutNodesCount, OUT PULONG OutNodes)
Definition: topology.c:972
struct MIXER_INFO * LPMIXER_INFO
const GUID KSNODETYPE_DAC
Definition: sup.c:15
const GUID KSPROPSETID_Audio
Definition: sup.c:29
const GUID KSPROPSETID_Pin
Definition: sup.c:30
const GUID KSNODETYPE_PEAKMETER
Definition: sup.c:22
MIXER_STATUS MMixerSetGetMuteControlDetails(IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN LPMIXERCONTROL_EXT MixerControl, IN ULONG dwLineID, IN LPMIXERCONTROLDETAILS MixerControlDetails, IN ULONG bSet)
Definition: sup.c:367
VOID MMixerFreeMixerInfo(IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo)
Definition: sup.c:116
LPMIXER_INFO MMixerGetMixerInfoByIndex(IN PMIXER_CONTEXT MixerContext, IN ULONG MixerIndex)
Definition: sup.c:161
const GUID KSDATAFORMAT_TYPE_MUSIC
Definition: sup.c:35
LPMIXER_DATA MMixerGetDataByDeviceName(IN PMIXER_LIST MixerList, IN LPWSTR DeviceName)
Definition: sup.c:759
const GUID KSEVENTSETID_AudioControlChange
Definition: sup.c:33
VOID MMixerInitializePinConnect(IN OUT PKSPIN_CONNECT PinConnect, IN ULONG PinId)
Definition: sup.c:904
const GUID KSNODETYPE_VOLUME
Definition: sup.c:21
MIXER_STATUS MMixerGetDeviceNameWithComponentId(IN PMIXER_CONTEXT MixerContext, IN HANDLE hMixer, OUT LPWSTR OutDeviceName)
Definition: sup.c:807
ULONG MMixerGetVolumeControlIndex(LPMIXERVOLUME_DATA VolumeData, LONG Value)
Definition: sup.c:322
const GUID KSNODETYPE_CHORUS
Definition: sup.c:25
const GUID KSNODETYPE_AGC
Definition: sup.c:17
const GUID KSNODETYPE_SUPERMIX
Definition: sup.c:27
LPGUID MMixerGetNodeType(IN PKSMULTIPLE_ITEM MultipleItem, IN ULONG Index)
Definition: sup.c:245
MIXER_STATUS MMixerSetGetMuxControlDetails(IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN ULONG NodeId, IN ULONG bSet, IN ULONG Flags, IN LPMIXERCONTROL_EXT MixerControl, IN LPMIXERCONTROLDETAILS MixerControlDetails, IN LPMIXERLINE_EXT MixerLine)
Definition: sup.c:411
const GUID KSNODETYPE_SUM
Definition: sup.c:14
MIXER_STATUS MMixerGetMixerByName(IN PMIXER_LIST MixerList, IN LPWSTR MixerName, OUT LPMIXER_INFO *OutMixerInfo)
Definition: sup.c:194
MIXER_STATUS MMixerGetDeviceName(IN PMIXER_CONTEXT MixerContext, OUT LPWSTR DeviceName, IN HANDLE hKey)
Definition: sup.c:855
const GUID KSDATAFORMAT_SPECIFIER_NONE
Definition: sup.c:37
const GUID KSNODETYPE_ADC
Definition: sup.c:16
MIXER_STATUS MMixerGetMixerControlById(LPMIXER_INFO MixerInfo, DWORD dwControlID, LPMIXERLINE_EXT *OutMixerLine, LPMIXERCONTROL_EXT *OutMixerControl, PULONG NodeId)
Definition: sup.c:281
const GUID KSNODETYPE_MUX
Definition: sup.c:23
const GUID KSNODETYPE_MUTE
Definition: sup.c:19
MIXER_STATUS MMixerVerifyContext(IN PMIXER_CONTEXT MixerContext)
Definition: sup.c:41
LPMIXERLINE_EXT MMixerGetSourceMixerLineByComponentType(LPMIXER_INFO MixerInfo, DWORD dwComponentType)
Definition: sup.c:258
VOID MMixerGetLowestLogicalTopologyPinOffsetFromArray(IN ULONG LogicalPinArrayCount, IN PULONG LogicalPinArray, OUT PULONG PinOffset)
Definition: sup.c:91
MIXER_STATUS MMixerSetGetVolumeControlDetails(IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN ULONG NodeId, IN ULONG bSet, LPMIXERCONTROL_EXT MixerControl, IN LPMIXERCONTROLDETAILS MixerControlDetails, LPMIXERLINE_EXT MixerLine)
Definition: sup.c:668
MIXER_STATUS MMixerCreateMixerData(IN PMIXER_CONTEXT MixerContext, IN PMIXER_LIST MixerList, IN ULONG DeviceId, IN LPWSTR DeviceName, IN HANDLE hDevice, IN HANDLE hKey)
Definition: sup.c:781
LPMIXERLINE_EXT MMixerGetMixerLineContainingNodeId(IN LPMIXER_INFO MixerInfo, IN ULONG NodeID)
Definition: sup.c:59
const GUID KSNODETYPE_STEREO_WIDE
Definition: sup.c:24
VOID MMixerNotifyControlChange(IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN ULONG NotificationType, IN ULONG Value)
Definition: sup.c:339
const GUID KSNODETYPE_REVERB
Definition: sup.c:26
const GUID KSNODETYPE_TONE
Definition: sup.c:20
LPMIXERLINE_EXT MMixerGetSourceMixerLineByLineId(LPMIXER_INFO MixerInfo, DWORD dwLineID)
Definition: sup.c:221
const GUID KSPROPSETID_General
Definition: sup.c:31
LPMIXER_DATA MMixerGetMixerDataByDeviceHandle(IN PMIXER_CONTEXT MixerContext, IN HANDLE hDevice)
Definition: sup.c:130
const GUID KSDATAFORMAT_SUBTYPE_MIDI
Definition: sup.c:36
const GUID KSPROPSETID_Topology
Definition: sup.c:32
LPMIXER_DATA MMixerGetDataByDeviceId(IN PMIXER_LIST MixerList, IN ULONG DeviceId)
Definition: sup.c:738
const GUID KSNODETYPE_LOUDNESS
Definition: sup.c:18
#define DPRINT
Definition: sndvol32.h:71
Definition: precomp.h:169
base of all file and directory entries
Definition: entries.h:83
HANDLE hDevice
Definition: precomp.h:81
MIXERCONTROLW Control
Definition: precomp.h:79
PVOID ExtraData
Definition: precomp.h:82
ULONG NodeID
Definition: precomp.h:80
MIXERLINEW Line
Definition: precomp.h:89
LIST_ENTRY ControlsList
Definition: precomp.h:90
ULONG ValuesCount
Definition: precomp.h:107
ULONG InputSteppingDelta
Definition: precomp.h:106
PMIXER_ALLOC_EVENT_DATA AllocEventData
Definition: mmixer.h:103
PMIXER_OPEN_KEY OpenKey
Definition: mmixer.h:100
PMIXER_DEVICE_CONTROL Control
Definition: mmixer.h:95
PMIXER_CLOSE Close
Definition: mmixer.h:98
ULONG SizeOfStruct
Definition: mmixer.h:91
PMIXER_CLOSEKEY CloseKey
Definition: mmixer.h:102
PMIXER_COPY Copy
Definition: mmixer.h:99
PMIXER_QUERY_KEY_VALUE QueryKeyValue
Definition: mmixer.h:101
PMIXER_FREE_EVENT_DATA FreeEventData
Definition: mmixer.h:104
PVOID MixerContext
Definition: mmixer.h:92
PMIXER_OPEN Open
Definition: mmixer.h:97
PMIXER_FREE Free
Definition: mmixer.h:96
PMIXER_ALLOC Alloc
Definition: mmixer.h:94
LIST_ENTRY Entry
Definition: precomp.h:113
LPMIXER_INFO MixerInfo
Definition: precomp.h:119
HANDLE hDevice
Definition: precomp.h:115
HANDLE hDeviceInterfaceKey
Definition: precomp.h:116
LPWSTR DeviceName
Definition: precomp.h:117
ULONG DeviceId
Definition: precomp.h:114
PTOPOLOGY Topology
Definition: precomp.h:118
LIST_ENTRY LineList
Definition: precomp.h:71
MIXERCAPSW MixCaps
Definition: precomp.h:70
ULONG MixerDataCount
Definition: precomp.h:152
LIST_ENTRY MixerData
Definition: precomp.h:153
ULONG MixerListCount
Definition: precomp.h:149
LIST_ENTRY MixerList
Definition: precomp.h:150
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
WCHAR szPname[MAXPNAMELEN]
Definition: mmsystem.h:1226
DWORD dwLineID
Definition: mmsystem.h:1258
WCHAR szName[MIXER_LONG_NAME_CHARS]
Definition: mmsystem.h:1266
DWORD dwComponentType
Definition: mmsystem.h:1261
#define MAXULONG
Definition: typedefs.h:251
uint32_t * PULONG
Definition: typedefs.h:59
#define IN
Definition: typedefs.h:39
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
_In_ WDFCOLLECTION _In_ ULONG Index
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG _Out_ PULONG ResultLength
Definition: wdfdevice.h:3776
_In_ WDF_SPECIAL_FILE_TYPE NotificationType
Definition: wdfdevice.h:1024
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3275
_In_ WDFREQUEST Request
Definition: wdfdevice.h:547
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_ ULONG _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PWDF_REQUEST_SEND_OPTIONS _Out_opt_ PULONG_PTR BytesReturned
Definition: wdfiotarget.h:1052
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
_In_ ULONG _In_opt_ PVOID _In_ PDRIVER_OBJECT _In_ PDRIVER_NOTIFICATION_CALLBACK_ROUTINE _Inout_opt_ __drv_aliasesMem PVOID _Outptr_result_nullonfailure_ _At_ * NotificationEntry(return==0, __drv_allocatesMem(Mem))) PVOID *NotificationEntry
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184