b94c59ce6eaa459a2dac970f45f0097c5db548c0
[reactos.git] / lib / drivers / sound / mmixer / controls.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Kernel Streaming
4 * FILE: lib/drivers/sound/mmixer/controls.c
5 * PURPOSE: Mixer Control Iteration Functions
6 * PROGRAMMER: Johannes Anderwald
7 */
8
9 #include "priv.h"
10
11 const GUID KSNODETYPE_DESKTOP_MICROPHONE = {0xDFF21BE2, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
12 const GUID KSNODETYPE_LEGACY_AUDIO_CONNECTOR = {0xDFF21FE4, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
13 const GUID KSNODETYPE_TELEPHONE = {0xDFF21EE2, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
14 const GUID KSNODETYPE_PHONE_LINE = {0xDFF21EE1, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
15 const GUID KSNODETYPE_DOWN_LINE_PHONE = {0xDFF21EE3, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
16 const GUID KSNODETYPE_DESKTOP_SPEAKER = {0xDFF21CE4, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
17 const GUID KSNODETYPE_ROOM_SPEAKER = {0xDFF21CE5, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
18 const GUID KSNODETYPE_COMMUNICATION_SPEAKER = {0xDFF21CE6, 0xF70F, 0x11D0, {0xB9,0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
19 const GUID KSNODETYPE_HEADPHONES = {0xDFF21CE2, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
20 const GUID KSNODETYPE_HEAD_MOUNTED_DISPLAY_AUDIO = {0xDFF21CE3, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
21 const GUID KSNODETYPE_MICROPHONE = {0xDFF21BE1, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9,0x22, 0x31, 0x96}};
22 const GUID KSCATEGORY_AUDIO = {0x6994AD04L, 0x93EF, 0x11D0, {0xA3, 0xCC, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
23 const GUID KSNODETYPE_SPDIF_INTERFACE = {0xDFF21FE5, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
24 const GUID KSNODETYPE_ANALOG_CONNECTOR = {0xDFF21FE1, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
25 const GUID KSNODETYPE_SPEAKER = {0xDFF21CE1, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
26 const GUID KSNODETYPE_CD_PLAYER = {0xDFF220E3, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
27 const GUID KSNODETYPE_SYNTHESIZER = {0xDFF220F3, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
28 const GUID KSNODETYPE_LINE_CONNECTOR = {0xDFF21FE3, 0xF70F, 0x11D0, {0xB9, 0x17, 0x00, 0xA0,0xC9, 0x22, 0x31, 0x96}};
29 const GUID PINNAME_VIDEO_CAPTURE = {0xfb6c4281, 0x353, 0x11d1, {0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba}};
30
31 MIXER_STATUS
32 MMixerAddMixerControl(
33 IN PMIXER_CONTEXT MixerContext,
34 IN LPMIXER_INFO MixerInfo,
35 IN PTOPOLOGY Topology,
36 IN ULONG NodeIndex,
37 IN LPMIXERLINE_EXT MixerLine,
38 OUT LPMIXERCONTROLW MixerControl)
39 {
40 LPGUID NodeType;
41 KSP_NODE Node;
42 ULONG BytesReturned;
43 MIXER_STATUS Status;
44 LPWSTR Name;
45
46 /* initialize mixer control */
47 MixerControl->cbStruct = sizeof(MIXERCONTROLW);
48 MixerControl->dwControlID = MixerInfo->ControlId;
49
50 /* get node type */
51 NodeType = MMixerGetNodeTypeFromTopology(Topology, NodeIndex);
52 /* store control type */
53 MixerControl->dwControlType = MMixerGetControlTypeFromTopologyNode(NodeType);
54
55 MixerControl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM; /* FIXME */
56 MixerControl->cMultipleItems = 0; /* FIXME */
57
58 if (MixerControl->dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE)
59 {
60 MixerControl->Bounds.dwMinimum = 0;
61 MixerControl->Bounds.dwMaximum = 1;
62 }
63 else if (MixerControl->dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME)
64 {
65 MixerControl->Bounds.dwMinimum = 0;
66 MixerControl->Bounds.dwMaximum = 0xFFFF;
67 MixerControl->Metrics.cSteps = 0xC0; /* FIXME */
68 }
69
70 /* setup request to retrieve name */
71 Node.NodeId = NodeIndex;
72 Node.Property.Id = KSPROPERTY_TOPOLOGY_NAME;
73 Node.Property.Flags = KSPROPERTY_TYPE_GET;
74 Node.Property.Set = KSPROPSETID_Topology;
75 Node.Reserved = 0;
76
77 /* get node name size */
78 Status = MixerContext->Control(MixerInfo->hMixer, IOCTL_KS_PROPERTY, (PVOID)&Node, sizeof(KSP_NODE), NULL, 0, &BytesReturned);
79
80 if (Status == MM_STATUS_MORE_ENTRIES)
81 {
82 ASSERT(BytesReturned != 0);
83 Name = (LPWSTR)MixerContext->Alloc(BytesReturned);
84 if (!Name)
85 {
86 /* not enough memory */
87 return MM_STATUS_NO_MEMORY;
88 }
89
90 /* get node name */
91 Status = MixerContext->Control(MixerInfo->hMixer, IOCTL_KS_PROPERTY, (PVOID)&Node, sizeof(KSP_NODE), (LPVOID)Name, BytesReturned, &BytesReturned);
92
93 if (Status == MM_STATUS_SUCCESS)
94 {
95 MixerContext->Copy(MixerControl->szShortName, Name, (min(MIXER_SHORT_NAME_CHARS, wcslen(Name)+1)) * sizeof(WCHAR));
96 MixerControl->szShortName[MIXER_SHORT_NAME_CHARS-1] = L'\0';
97
98 MixerContext->Copy(MixerControl->szName, Name, (min(MIXER_LONG_NAME_CHARS, wcslen(Name)+1)) * sizeof(WCHAR));
99 MixerControl->szName[MIXER_LONG_NAME_CHARS-1] = L'\0';
100 }
101
102 /* free name buffer */
103 MixerContext->Free(Name);
104 }
105
106 MixerInfo->ControlId++;
107 #if 0
108 if (MixerControl->dwControlType == MIXERCONTROL_CONTROLTYPE_MUX)
109 {
110 KSNODEPROPERTY Property;
111 ULONG PinId = 2;
112
113 /* setup the request */
114 RtlZeroMemory(&Property, sizeof(KSNODEPROPERTY));
115
116 Property.NodeId = NodeIndex;
117 Property.Property.Id = KSPROPERTY_AUDIO_MUX_SOURCE;
118 Property.Property.Flags = KSPROPERTY_TYPE_SET;
119 Property.Property.Set = KSPROPSETID_Audio;
120
121 /* get node volume level info */
122 Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSNODEPROPERTY), (PVOID)&PinId, sizeof(ULONG), &BytesReturned);
123
124 DPRINT1("Status %x NodeIndex %u PinId %u\n", Status, NodeIndex, PinId);
125 //DbgBreakPoint();
126 }else
127 #endif
128 if (MixerControl->dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME)
129 {
130 KSNODEPROPERTY_AUDIO_CHANNEL Property;
131 ULONG Length;
132 PKSPROPERTY_DESCRIPTION Desc;
133 PKSPROPERTY_MEMBERSHEADER Members;
134 PKSPROPERTY_STEPPING_LONG Range;
135
136 Length = sizeof(KSPROPERTY_DESCRIPTION) + sizeof(KSPROPERTY_MEMBERSHEADER) + sizeof(KSPROPERTY_STEPPING_LONG);
137 Desc = (PKSPROPERTY_DESCRIPTION)MixerContext->Alloc(Length);
138 ASSERT(Desc);
139
140 /* setup the request */
141 RtlZeroMemory(&Property, sizeof(KSNODEPROPERTY_AUDIO_CHANNEL));
142
143 Property.NodeProperty.NodeId = NodeIndex;
144 Property.NodeProperty.Property.Id = KSPROPERTY_AUDIO_VOLUMELEVEL;
145 Property.NodeProperty.Property.Flags = KSPROPERTY_TYPE_BASICSUPPORT;
146 Property.NodeProperty.Property.Set = KSPROPSETID_Audio;
147
148 /* get node volume level info */
149 Status = MixerContext->Control(MixerInfo->hMixer, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSNODEPROPERTY_AUDIO_CHANNEL), Desc, Length, &BytesReturned);
150
151 if (Status == MM_STATUS_SUCCESS)
152 {
153 LPMIXERVOLUME_DATA VolumeData;
154 ULONG Steps, MaxRange, Index;
155 LONG Value;
156
157 Members = (PKSPROPERTY_MEMBERSHEADER)(Desc + 1);
158 Range = (PKSPROPERTY_STEPPING_LONG)(Members + 1);
159
160 DPRINT("NodeIndex %u Range Min %d Max %d Steps %x UMin %x UMax %x\n", NodeIndex, Range->Bounds.SignedMinimum, Range->Bounds.SignedMaximum, Range->SteppingDelta, Range->Bounds.UnsignedMinimum, Range->Bounds.UnsignedMaximum);
161
162 MaxRange = Range->Bounds.UnsignedMaximum - Range->Bounds.UnsignedMinimum;
163
164 if (MaxRange)
165 {
166 ASSERT(MaxRange);
167 VolumeData = (LPMIXERVOLUME_DATA)MixerContext->Alloc(sizeof(MIXERVOLUME_DATA));
168 if (!VolumeData)
169 return MM_STATUS_NO_MEMORY;
170
171 Steps = MaxRange / Range->SteppingDelta + 1;
172
173 /* store mixer control info there */
174 VolumeData->Header.dwControlID = MixerControl->dwControlID;
175 VolumeData->SignedMaximum = Range->Bounds.SignedMaximum;
176 VolumeData->SignedMinimum = Range->Bounds.SignedMinimum;
177 VolumeData->SteppingDelta = Range->SteppingDelta;
178 VolumeData->ValuesCount = Steps;
179 VolumeData->InputSteppingDelta = 0x10000 / Steps;
180
181 VolumeData->Values = (PLONG)MixerContext->Alloc(sizeof(LONG) * Steps);
182 if (!VolumeData->Values)
183 {
184 MixerContext->Free(Desc);
185 MixerContext->Free(VolumeData);
186 return MM_STATUS_NO_MEMORY;
187 }
188
189 Value = Range->Bounds.SignedMinimum;
190 for(Index = 0; Index < Steps; Index++)
191 {
192 VolumeData->Values[Index] = Value;
193 Value += Range->SteppingDelta;
194 }
195 InsertTailList(&MixerLine->LineControlsExtraData, &VolumeData->Header.Entry);
196 }
197 }
198 MixerContext->Free(Desc);
199 }
200
201 DPRINT("Status %x Name %S\n", Status, MixerControl->szName);
202 return MM_STATUS_SUCCESS;
203 }
204
205 MIXER_STATUS
206 MMixerCreateDestinationLine(
207 IN PMIXER_CONTEXT MixerContext,
208 IN LPMIXER_INFO MixerInfo,
209 IN ULONG bInputMixer,
210 IN LPWSTR LineName)
211 {
212 LPMIXERLINE_EXT DestinationLine;
213
214 /* allocate a mixer destination line */
215 DestinationLine = (LPMIXERLINE_EXT) MixerContext->Alloc(sizeof(MIXERLINE_EXT));
216 if (!MixerInfo)
217 {
218 /* no memory */
219 return MM_STATUS_NO_MEMORY;
220 }
221
222 /* initialize mixer destination line */
223 DestinationLine->Line.cbStruct = sizeof(MIXERLINEW);
224 DestinationLine->Line.dwSource = MAXULONG;
225 DestinationLine->Line.dwLineID = MixerInfo->MixCaps.cDestinations + DESTINATION_LINE;
226 DestinationLine->Line.fdwLine = MIXERLINE_LINEF_ACTIVE;
227 DestinationLine->Line.dwUser = 0;
228 DestinationLine->Line.dwDestination = MixerInfo->MixCaps.cDestinations;
229 DestinationLine->Line.dwComponentType = (bInputMixer == 0 ? MIXERLINE_COMPONENTTYPE_DST_SPEAKERS : MIXERLINE_COMPONENTTYPE_DST_WAVEIN);
230 DestinationLine->Line.cChannels = 2; /* FIXME */
231
232 if (LineName)
233 {
234 MixerContext->Copy(DestinationLine->Line.szShortName, LineName, (min(MIXER_SHORT_NAME_CHARS, wcslen(LineName)+1)) * sizeof(WCHAR));
235 DestinationLine->Line.szShortName[MIXER_SHORT_NAME_CHARS-1] = L'\0';
236
237 MixerContext->Copy(DestinationLine->Line.szName, LineName, (min(MIXER_LONG_NAME_CHARS, wcslen(LineName)+1)) * sizeof(WCHAR));
238 DestinationLine->Line.szName[MIXER_LONG_NAME_CHARS-1] = L'\0';
239
240 }
241
242 DestinationLine->Line.Target.dwType = (bInputMixer == 0 ? MIXERLINE_TARGETTYPE_WAVEOUT : MIXERLINE_TARGETTYPE_WAVEIN);
243 DestinationLine->Line.Target.dwDeviceID = 0; //FIXME
244 DestinationLine->Line.Target.wMid = MixerInfo->MixCaps.wMid;
245 DestinationLine->Line.Target.wPid = MixerInfo->MixCaps.wPid;
246 DestinationLine->Line.Target.vDriverVersion = MixerInfo->MixCaps.vDriverVersion;
247
248 ASSERT(MixerInfo->MixCaps.szPname[MAXPNAMELEN-1] == 0);
249 wcscpy(DestinationLine->Line.Target.szPname, MixerInfo->MixCaps.szPname);
250
251 /* initialize extra line */
252 InitializeListHead(&DestinationLine->LineControlsExtraData);
253
254 /* insert into mixer info */
255 InsertTailList(&MixerInfo->LineList, &DestinationLine->Entry);
256
257 /* increment destination count */
258 MixerInfo->MixCaps.cDestinations++;
259
260 /* done */
261 return MM_STATUS_SUCCESS;
262 }
263
264 MIXER_STATUS
265 MMixerGetPinName(
266 IN PMIXER_CONTEXT MixerContext,
267 IN LPMIXER_INFO MixerInfo,
268 IN ULONG PinId,
269 IN OUT LPWSTR * OutBuffer)
270 {
271 KSP_PIN Pin;
272 ULONG BytesReturned;
273 LPWSTR Buffer;
274 MIXER_STATUS Status;
275
276 /* prepare pin */
277 Pin.PinId = PinId;
278 Pin.Reserved = 0;
279 Pin.Property.Flags = KSPROPERTY_TYPE_GET;
280 Pin.Property.Set = KSPROPSETID_Pin;
281 Pin.Property.Id = KSPROPERTY_PIN_NAME;
282
283 /* try get pin name size */
284 Status = MixerContext->Control(MixerInfo->hMixer, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), NULL, 0, &BytesReturned);
285
286 /* check if buffer overflowed */
287 if (Status == MM_STATUS_MORE_ENTRIES)
288 {
289 /* allocate buffer */
290 Buffer = (LPWSTR)MixerContext->Alloc(BytesReturned);
291 if (!Buffer)
292 {
293 /* out of memory */
294 return MM_STATUS_NO_MEMORY;
295 }
296
297 /* try get pin name */
298 Status = MixerContext->Control(MixerInfo->hMixer, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)Buffer, BytesReturned, &BytesReturned);
299 if (Status != MM_STATUS_SUCCESS)
300 {
301 /* failed to get pin name */
302 MixerContext->Free((PVOID)Buffer);
303 return Status;
304 }
305
306 /* successfully obtained pin name */
307 *OutBuffer = Buffer;
308 return MM_STATUS_SUCCESS;
309 }
310
311 /* failed to get pin name */
312 return Status;
313 }
314
315 MIXER_STATUS
316 MMixerBuildMixerDestinationLine(
317 IN PMIXER_CONTEXT MixerContext,
318 IN OUT LPMIXER_INFO MixerInfo,
319 IN ULONG PinId,
320 IN ULONG bInput)
321 {
322 LPWSTR PinName;
323 MIXER_STATUS Status;
324
325 /* try get pin name */
326 Status = MMixerGetPinName(MixerContext, MixerInfo, PinId, &PinName);
327 if (Status == MM_STATUS_SUCCESS)
328 {
329 /* create mixer destination line */
330
331 Status = MMixerCreateDestinationLine(MixerContext, MixerInfo, bInput, PinName);
332
333 /* free pin name */
334 MixerContext->Free(PinName);
335 }
336 else
337 {
338 /* create mixer destination line unlocalized */
339 Status = MMixerCreateDestinationLine(MixerContext, MixerInfo, bInput, L"No Name");
340 }
341
342 return Status;
343 }
344
345 MIXER_STATUS
346 MMixerBuildTopology(
347 IN PMIXER_CONTEXT MixerContext,
348 IN LPMIXER_DATA MixerData,
349 OUT PTOPOLOGY * OutTopology)
350 {
351 ULONG PinsCount;
352 PKSMULTIPLE_ITEM NodeTypes = NULL;
353 PKSMULTIPLE_ITEM NodeConnections = NULL;
354 MIXER_STATUS Status;
355
356 if (MixerData->Topology)
357 {
358 /* re-use existing topology */
359 *OutTopology = MixerData->Topology;
360
361 return MM_STATUS_SUCCESS;
362 }
363
364 /* get connected filter pin count */
365 PinsCount = MMixerGetFilterPinCount(MixerContext, MixerData->hDevice);
366
367 if (!PinsCount)
368 {
369 /* referenced filter does not have any pins */
370 return MM_STATUS_UNSUCCESSFUL;
371 }
372
373 /* get topology node types */
374 Status = MMixerGetFilterTopologyProperty(MixerContext, MixerData->hDevice, KSPROPERTY_TOPOLOGY_NODES, &NodeTypes);
375 if (Status != MM_STATUS_SUCCESS)
376 {
377 /* failed to get topology node types */
378 return Status;
379 }
380
381 /* get topology connections */
382 Status = MMixerGetFilterTopologyProperty(MixerContext, MixerData->hDevice, KSPROPERTY_TOPOLOGY_CONNECTIONS, &NodeConnections);
383 if (Status != MM_STATUS_SUCCESS)
384 {
385 /* failed to get topology connections */
386 MixerContext->Free(NodeTypes);
387 return Status;
388 }
389
390 /* create a topology */
391 Status = MMixerCreateTopology(MixerContext, PinsCount, NodeConnections, NodeTypes, OutTopology);
392
393 /* free node types & connections */
394 MixerContext->Free(NodeConnections);
395 MixerContext->Free(NodeTypes);
396
397 if (Status == MM_STATUS_SUCCESS)
398 {
399 /* store topology object */
400 MixerData->Topology = *OutTopology;
401 }
402
403 /* done */
404 return Status;
405 }
406
407 MIXER_STATUS
408 MMixerCountMixerControls(
409 IN PMIXER_CONTEXT MixerContext,
410 IN PTOPOLOGY Topology,
411 IN ULONG PinId,
412 IN ULONG bInputMixer,
413 IN ULONG bUpStream,
414 OUT PULONG OutNodesCount,
415 OUT PULONG OutNodes,
416 OUT PULONG OutLineTerminator)
417 {
418 PULONG Nodes;
419 ULONG NodesCount, NodeIndex, Count, bTerminator;
420 MIXER_STATUS Status;
421
422 /* allocate an array to store all nodes which are upstream of this pin */
423 Status = MMixerAllocateTopologyNodeArray(MixerContext, Topology, &Nodes);
424
425 if (Status != MM_STATUS_SUCCESS)
426 {
427 /* out of memory */
428 return STATUS_NO_MEMORY;
429 }
430
431 /* mark result array as zero */
432 *OutNodesCount = 0;
433
434 /* get next nodes */
435 MMixerGetNextNodesFromPinIndex(MixerContext, Topology, PinId, bUpStream, &NodesCount, Nodes);
436
437 /* assume no topology split before getting line terminator */
438 ASSERT(NodesCount == 1);
439
440 /* get first node */
441 NodeIndex = Nodes[0];
442 Count = 0;
443
444 do
445 {
446 /* check if the node is a terminator */
447 MMixerIsNodeTerminator(Topology, NodeIndex, &bTerminator);
448
449 if (bTerminator)
450 {
451 /* found terminator */
452 if (bInputMixer)
453 {
454 /* add mux source for source destination line */
455 OutNodes[Count] = NodeIndex;
456 Count++;
457 }
458 break;
459 }
460
461 /* store node id */
462 OutNodes[Count] = NodeIndex;
463
464 /* increment node count */
465 Count++;
466
467 /* get next nodes upstream */
468 MMixerGetNextNodesFromNodeIndex(MixerContext, Topology, NodeIndex, bUpStream, &NodesCount, Nodes);
469
470 /* assume there is a node connected */
471 ASSERT(NodesCount != 0);
472 ASSERT(NodesCount == 1);
473
474 /* use first index */
475 NodeIndex = Nodes[0];
476
477 }while(TRUE);
478
479 /* free node index */
480 MixerContext->Free(Nodes);
481
482 /* store nodes count */
483 *OutNodesCount = Count;
484
485 /* store line terminator */
486 *OutLineTerminator = NodeIndex;
487
488 /* done */
489 return MM_STATUS_SUCCESS;
490 }
491
492 MIXER_STATUS
493 MMixerGetChannelCountEnhanced(
494 IN PMIXER_CONTEXT MixerContext,
495 IN LPMIXER_INFO MixerInfo,
496 IN ULONG NodeId,
497 OUT PULONG MaxChannels)
498 {
499 KSPROPERTY_DESCRIPTION Description;
500 PKSPROPERTY_DESCRIPTION NewDescription;
501 PKSPROPERTY_MEMBERSHEADER Header;
502 ULONG BytesReturned;
503 KSP_NODE Request;
504 MIXER_STATUS Status;
505
506 /* try #1 obtain it via description */
507 Request.NodeId = NodeId;
508 Request.Reserved = 0;
509 Request.Property.Set = KSPROPSETID_Audio;
510 Request.Property.Flags = KSPROPERTY_TYPE_BASICSUPPORT | KSPROPERTY_TYPE_TOPOLOGY;
511 Request.Property.Id = KSPROPERTY_AUDIO_VOLUMELEVEL;
512
513
514 /* get description */
515 Status = MixerContext->Control(MixerInfo->hMixer, IOCTL_KS_PROPERTY, (PVOID)&Request, sizeof(KSP_NODE), (PVOID)&Description, sizeof(KSPROPERTY_DESCRIPTION), &BytesReturned);
516 if (Status == MM_STATUS_SUCCESS)
517 {
518 if (Description.DescriptionSize >= sizeof(KSPROPERTY_DESCRIPTION) + sizeof(KSPROPERTY_MEMBERSHEADER) && (Description.MembersListCount > 0))
519 {
520 /* allocate new description */
521 NewDescription = MixerContext->Alloc(Description.DescriptionSize);
522
523 if (!NewDescription)
524 {
525 /* not enough memory */
526 return MM_STATUS_NO_MEMORY;
527 }
528
529 /* get description */
530 Status = MixerContext->Control(MixerInfo->hMixer, IOCTL_KS_PROPERTY, (PVOID)&Request, sizeof(KSP_NODE), (PVOID)NewDescription, Description.DescriptionSize, &BytesReturned);
531 if (Status == MM_STATUS_SUCCESS)
532 {
533 /* get header */
534 Header = (PKSPROPERTY_MEMBERSHEADER)(NewDescription + 1);
535
536 if (Header->Flags & KSPROPERTY_MEMBER_FLAG_BASICSUPPORT_MULTICHANNEL)
537 {
538 /* found enhanced flag */
539 ASSERT(Header->MembersCount > 1);
540
541 /* store channel count */
542 *MaxChannels = Header->MembersCount;
543
544 /* free description */
545 MixerContext->Free(NewDescription);
546
547 /* done */
548 return MM_STATUS_SUCCESS;
549 }
550 }
551
552 /* free description */
553 MixerContext->Free(NewDescription);
554 }
555 }
556
557 /* failed to get channel count enhanced */
558 return MM_STATUS_UNSUCCESSFUL;
559 }
560
561 VOID
562 MMixerGetChannelCountLegacy(
563 IN PMIXER_CONTEXT MixerContext,
564 IN LPMIXER_INFO MixerInfo,
565 IN ULONG NodeId,
566 OUT PULONG MaxChannels)
567 {
568 ULONG BytesReturned;
569 MIXER_STATUS Status;
570 KSNODEPROPERTY_AUDIO_CHANNEL Channel;
571 LONG Volume;
572
573 /* setup request */
574 Channel.Reserved = 0;
575 Channel.NodeProperty.NodeId = NodeId;
576 Channel.NodeProperty.Reserved = 0;
577 Channel.NodeProperty.Property.Flags = KSPROPERTY_TYPE_GET | KSPROPERTY_TYPE_TOPOLOGY;
578 Channel.NodeProperty.Property.Set = KSPROPSETID_Audio;
579 Channel.Channel = 0;
580 Channel.NodeProperty.Property.Id = KSPROPERTY_AUDIO_VOLUMELEVEL;
581
582 do
583 {
584 /* get channel volume */
585 Status = MixerContext->Control(MixerInfo->hMixer, IOCTL_KS_PROPERTY, (PVOID)&Channel, sizeof(KSNODEPROPERTY_AUDIO_CHANNEL), (PVOID)&Volume, sizeof(LONG), &BytesReturned);
586 if (Status != MM_STATUS_SUCCESS)
587 break;
588
589 /* increment channel count */
590 Channel.Channel++;
591
592 }while(TRUE);
593
594 /* store channel count */
595 *MaxChannels = Channel.Channel;
596
597 }
598
599 VOID
600 MMixerGetMaxChannelsForNode(
601 IN PMIXER_CONTEXT MixerContext,
602 IN LPMIXER_INFO MixerInfo,
603 IN ULONG NodeId,
604 OUT PULONG MaxChannels)
605 {
606 MIXER_STATUS Status;
607
608 /* try to get it enhanced */
609 Status = MMixerGetChannelCountEnhanced(MixerContext, MixerInfo, NodeId, MaxChannels);
610
611 if (Status != MM_STATUS_SUCCESS)
612 {
613 /* get it old-fashioned way */
614 MMixerGetChannelCountLegacy(MixerContext, MixerInfo, NodeId, MaxChannels);
615 }
616 }
617
618 MIXER_STATUS
619 MMixerAddMixerControlsToMixerLineByNodeIndexArray(
620 IN PMIXER_CONTEXT MixerContext,
621 IN LPMIXER_INFO MixerInfo,
622 IN PTOPOLOGY Topology,
623 IN OUT LPMIXERLINE_EXT DstLine,
624 IN ULONG NodesCount,
625 IN PULONG Nodes)
626 {
627 ULONG Index, Count, bReserved;
628 MIXER_STATUS Status;
629 LPGUID NodeType;
630 ULONG MaxChannels;
631
632 /* store nodes array */
633 DstLine->NodeIds = Nodes;
634
635 /* allocate MIXERCONTROLSW array */
636 DstLine->LineControls = MixerContext->Alloc(NodesCount * sizeof(MIXERCONTROLW));
637
638 if (!DstLine->LineControls)
639 {
640 /* out of memory */
641 return MM_STATUS_NO_MEMORY;
642 }
643
644 /* initialize control count */
645 Count = 0;
646
647 for(Index = 0; Index < NodesCount; Index++)
648 {
649 /* check if the node has already been reserved to a line */
650 MMixerIsTopologyNodeReserved(Topology, Nodes[Index], &bReserved);
651 #if 0 /* MS lies */
652 if (bReserved)
653 {
654 /* node is already used, skip it */
655 continue;
656 }
657 #endif
658 /* set node status as used */
659 MMixerSetTopologyNodeReserved(Topology, Nodes[Index]);
660
661 /* query node type */
662 NodeType = MMixerGetNodeTypeFromTopology(Topology, Nodes[Index]);
663
664 if (IsEqualGUIDAligned(NodeType, &KSNODETYPE_VOLUME))
665 {
666 /* calculate maximum channel count for node */
667 MMixerGetMaxChannelsForNode(MixerContext, MixerInfo, Nodes[Index], &MaxChannels);
668
669 DPRINT("NodeId %lu MaxChannels %lu Line %S Id %lu\n", Nodes[Index], MaxChannels, DstLine->Line.szName, DstLine->Line.dwLineID);
670 /* calculate maximum channels */
671 DstLine->Line.cChannels = min(DstLine->Line.cChannels, MaxChannels);
672 }
673
674
675 /* now add the mixer control */
676 Status = MMixerAddMixerControl(MixerContext, MixerInfo, Topology, Nodes[Index], DstLine, &DstLine->LineControls[Count]);
677
678 if (Status == MM_STATUS_SUCCESS)
679 {
680 /* increment control count */
681 Count++;
682 }
683 }
684
685 /* store control count */
686 DstLine->Line.cControls = Count;
687
688 /* done */
689 return MM_STATUS_SUCCESS;
690 }
691
692 MIXER_STATUS
693 MMixerGetComponentAndTargetType(
694 IN PMIXER_CONTEXT MixerContext,
695 IN OUT LPMIXER_INFO MixerInfo,
696 IN ULONG PinId,
697 OUT PULONG ComponentType,
698 OUT PULONG TargetType)
699 {
700 KSPIN_DATAFLOW DataFlow;
701 KSPIN_COMMUNICATION Communication;
702 MIXER_STATUS Status;
703 KSP_PIN Request;
704 ULONG BytesReturned;
705 GUID Guid;
706 BOOLEAN BridgePin = FALSE;
707 PKSPIN_PHYSICALCONNECTION Connection;
708
709 /* first dataflow type */
710 Status = MMixerGetPinDataFlowAndCommunication(MixerContext, MixerInfo->hMixer, PinId, &DataFlow, &Communication);
711
712 if (Status != MM_STATUS_SUCCESS)
713 {
714 /* failed to get dataflow */
715 return Status;
716 }
717
718 /* now get pin category guid */
719 Request.PinId = PinId;
720 Request.Reserved = 0;
721 Request.Property.Flags = KSPROPERTY_TYPE_GET;
722 Request.Property.Set = KSPROPSETID_Pin;
723 Request.Property.Id = KSPROPERTY_PIN_CATEGORY;
724
725
726 /* get pin category */
727 Status = MixerContext->Control(MixerInfo->hMixer, IOCTL_KS_PROPERTY, (PVOID)&Request, sizeof(KSP_PIN), &Guid, sizeof(GUID), &BytesReturned);
728 if (Status != MM_STATUS_SUCCESS)
729 {
730 /* failed to get dataflow */
731 return Status;
732 }
733
734 /* check if it has a physical connection */
735 Status = MMixerGetPhysicalConnection(MixerContext, MixerInfo->hMixer, PinId, &Connection);
736 if (Status == MM_STATUS_SUCCESS)
737 {
738 /* pin is a brige pin */
739 BridgePin = TRUE;
740
741 /* free physical connection */
742 MixerContext->Free(Connection);
743 }
744
745 if (DataFlow == KSPIN_DATAFLOW_IN)
746 {
747 if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_MICROPHONE) ||
748 IsEqualGUIDAligned(&Guid, &KSNODETYPE_DESKTOP_MICROPHONE))
749 {
750 /* type microphone */
751 *TargetType = MIXERLINE_TARGETTYPE_WAVEIN;
752 *ComponentType = MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
753 }
754 else if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_LEGACY_AUDIO_CONNECTOR) ||
755 IsEqualGUIDAligned(&Guid, &KSCATEGORY_AUDIO) ||
756 IsEqualGUIDAligned(&Guid, &KSNODETYPE_SPEAKER))
757 {
758 /* type waveout */
759 *TargetType = MIXERLINE_TARGETTYPE_WAVEOUT;
760 *ComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
761 }
762 else if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_CD_PLAYER))
763 {
764 /* type cd player */
765 *TargetType = MIXERLINE_TARGETTYPE_UNDEFINED;
766 *ComponentType = MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;
767 }
768 else if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_SYNTHESIZER))
769 {
770 /* type synthesizer */
771 *TargetType = MIXERLINE_TARGETTYPE_MIDIOUT;
772 *ComponentType = MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;
773 }
774 else if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_LINE_CONNECTOR))
775 {
776 /* type line */
777 *TargetType = MIXERLINE_TARGETTYPE_UNDEFINED;
778 *ComponentType = MIXERLINE_COMPONENTTYPE_SRC_LINE;
779 }
780 else if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_TELEPHONE) ||
781 IsEqualGUIDAligned(&Guid, &KSNODETYPE_PHONE_LINE) ||
782 IsEqualGUIDAligned(&Guid, &KSNODETYPE_DOWN_LINE_PHONE))
783 {
784 /* type telephone */
785 *TargetType = MIXERLINE_TARGETTYPE_UNDEFINED;
786 *ComponentType = MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE;
787 }
788 else if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_ANALOG_CONNECTOR))
789 {
790 /* type analog */
791 if (BridgePin)
792 *TargetType = MIXERLINE_TARGETTYPE_WAVEIN;
793 else
794 *TargetType = MIXERLINE_TARGETTYPE_WAVEOUT;
795
796 *ComponentType = MIXERLINE_COMPONENTTYPE_SRC_ANALOG;
797 }
798 else if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_SPDIF_INTERFACE))
799 {
800 /* type analog */
801 if (BridgePin)
802 *TargetType = MIXERLINE_TARGETTYPE_WAVEIN;
803 else
804 *TargetType = MIXERLINE_TARGETTYPE_WAVEOUT;
805
806 *ComponentType = MIXERLINE_COMPONENTTYPE_SRC_DIGITAL;
807 }
808 else
809 {
810 /* unknown type */
811 *TargetType = MIXERLINE_TARGETTYPE_UNDEFINED;
812 *ComponentType = MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED;
813 DPRINT1("Unknown Category for PinId %lu BridgePin %lu\n", PinId, BridgePin);
814 }
815 }
816 else
817 {
818 if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_SPEAKER) ||
819 IsEqualGUIDAligned(&Guid, &KSNODETYPE_DESKTOP_SPEAKER) ||
820 IsEqualGUIDAligned(&Guid, &KSNODETYPE_ROOM_SPEAKER) ||
821 IsEqualGUIDAligned(&Guid, &KSNODETYPE_COMMUNICATION_SPEAKER))
822 {
823 /* type waveout */
824 *TargetType = MIXERLINE_TARGETTYPE_WAVEOUT;
825 *ComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
826 }
827 else if (IsEqualGUIDAligned(&Guid, &KSCATEGORY_AUDIO) ||
828 IsEqualGUIDAligned(&Guid, &PINNAME_CAPTURE))
829 {
830 /* type wavein */
831 *TargetType = MIXERLINE_TARGETTYPE_WAVEIN;
832 *ComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
833 }
834 else if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_HEADPHONES) ||
835 IsEqualGUIDAligned(&Guid, &KSNODETYPE_HEAD_MOUNTED_DISPLAY_AUDIO))
836 {
837 /* type head phones */
838 *TargetType = MIXERLINE_TARGETTYPE_WAVEOUT;
839 *ComponentType = MIXERLINE_COMPONENTTYPE_DST_HEADPHONES;
840 }
841 else if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_TELEPHONE) ||
842 IsEqualGUIDAligned(&Guid, &KSNODETYPE_PHONE_LINE) ||
843 IsEqualGUIDAligned(&Guid, &KSNODETYPE_DOWN_LINE_PHONE))
844 {
845 /* type waveout */
846 *TargetType = MIXERLINE_TARGETTYPE_UNDEFINED;
847 *ComponentType = MIXERLINE_COMPONENTTYPE_DST_TELEPHONE;
848 }
849 else if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_ANALOG_CONNECTOR))
850 {
851 /* type analog */
852 if (BridgePin)
853 {
854 *TargetType = MIXERLINE_TARGETTYPE_WAVEOUT;
855 *ComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
856 }
857 else
858 {
859 *TargetType = MIXERLINE_TARGETTYPE_WAVEIN;
860 *ComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
861 }
862 }
863 else if (IsEqualGUIDAligned(&Guid, &KSNODETYPE_SPDIF_INTERFACE))
864 {
865 /* type spdif */
866 if (BridgePin)
867 {
868 *TargetType = MIXERLINE_TARGETTYPE_WAVEOUT;
869 *ComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
870 }
871 else
872 {
873 *TargetType = MIXERLINE_TARGETTYPE_WAVEIN;
874 *ComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
875 }
876 }
877 else
878 {
879 /* unknown type */
880 *TargetType = MIXERLINE_TARGETTYPE_UNDEFINED;
881 *ComponentType = MIXERLINE_COMPONENTTYPE_DST_UNDEFINED;
882 DPRINT1("Unknown Category for PinId %lu BridgePin %lu\n", PinId, BridgePin);
883 }
884 }
885
886 /* done */
887 return MM_STATUS_SUCCESS;
888 }
889
890 MIXER_STATUS
891 MMixerBuildMixerSourceLine(
892 IN PMIXER_CONTEXT MixerContext,
893 IN OUT LPMIXER_INFO MixerInfo,
894 IN PTOPOLOGY Topology,
895 IN ULONG PinId,
896 IN ULONG NodesCount,
897 IN PULONG Nodes,
898 IN ULONG DestinationLineID,
899 OUT LPMIXERLINE_EXT * OutSrcLine)
900 {
901 LPMIXERLINE_EXT SrcLine, DstLine;
902 LPWSTR PinName;
903 MIXER_STATUS Status;
904 ULONG ComponentType, TargetType;
905
906 /* get component and target type */
907 Status = MMixerGetComponentAndTargetType(MixerContext, MixerInfo, PinId, &ComponentType, &TargetType);
908 if (Status != MM_STATUS_SUCCESS)
909 {
910 /* failed to get component status */
911 TargetType = MIXERLINE_TARGETTYPE_UNDEFINED;
912 ComponentType = MIXERLINE_COMPONENTTYPE_DST_UNDEFINED;
913 }
914
915 /* construct source line */
916 SrcLine = (LPMIXERLINE_EXT)MixerContext->Alloc(sizeof(MIXERLINE_EXT));
917
918 if (!SrcLine)
919 {
920 /* no memory */
921 return MM_STATUS_NO_MEMORY;
922 }
923
924 /* get destination line */
925 DstLine = MMixerGetSourceMixerLineByLineId(MixerInfo, DestinationLineID);
926 ASSERT(DstLine);
927
928 /* initialize mixer src line */
929 SrcLine->hDevice = MixerInfo->hMixer;
930 SrcLine->PinId = PinId;
931 SrcLine->NodeIds = Nodes;
932
933 /* initialize mixer line */
934 SrcLine->Line.cbStruct = sizeof(MIXERLINEW);
935 SrcLine->Line.dwDestination = MixerInfo->MixCaps.cDestinations-1;
936 SrcLine->Line.dwSource = DstLine->Line.cConnections;
937 SrcLine->Line.dwLineID = (DstLine->Line.cConnections * SOURCE_LINE)+ (MixerInfo->MixCaps.cDestinations-1);
938 SrcLine->Line.fdwLine = MIXERLINE_LINEF_ACTIVE | MIXERLINE_LINEF_SOURCE;
939 SrcLine->Line.dwComponentType = ComponentType;
940 SrcLine->Line.dwUser = 0;
941 SrcLine->Line.cChannels = DstLine->Line.cChannels;
942 SrcLine->Line.cConnections = 0;
943 SrcLine->Line.Target.dwType = TargetType;
944 SrcLine->Line.Target.dwDeviceID = DstLine->Line.Target.dwDeviceID;
945 SrcLine->Line.Target.wMid = MixerInfo->MixCaps.wMid;
946 SrcLine->Line.Target.wPid = MixerInfo->MixCaps.wPid;
947 SrcLine->Line.Target.vDriverVersion = MixerInfo->MixCaps.vDriverVersion;
948 InitializeListHead(&SrcLine->LineControlsExtraData);
949
950 /* copy name */
951 ASSERT(MixerInfo->MixCaps.szPname[MAXPNAMELEN-1] == L'\0');
952 wcscpy(SrcLine->Line.Target.szPname, MixerInfo->MixCaps.szPname);
953
954 /* get pin name */
955 Status = MMixerGetPinName(MixerContext, MixerInfo, PinId, &PinName);
956
957 if (Status == MM_STATUS_SUCCESS)
958 {
959 /* store pin name as line name */
960 MixerContext->Copy(SrcLine->Line.szShortName, PinName, (min(MIXER_SHORT_NAME_CHARS, wcslen(PinName)+1)) * sizeof(WCHAR));
961 SrcLine->Line.szShortName[MIXER_SHORT_NAME_CHARS-1] = L'\0';
962
963 MixerContext->Copy(SrcLine->Line.szName, PinName, (min(MIXER_LONG_NAME_CHARS, wcslen(PinName)+1)) * sizeof(WCHAR));
964 SrcLine->Line.szName[MIXER_LONG_NAME_CHARS-1] = L'\0';
965
966 /* free pin name buffer */
967 MixerContext->Free(PinName);
968 }
969
970 /* add the controls to mixer line */
971 Status = MMixerAddMixerControlsToMixerLineByNodeIndexArray(MixerContext, MixerInfo, Topology, SrcLine, NodesCount, Nodes);
972 if (Status != MM_STATUS_SUCCESS)
973 {
974 /* failed */
975 return Status;
976 }
977
978 /* store result */
979 *OutSrcLine = SrcLine;
980
981 return MM_STATUS_SUCCESS;
982 }
983
984 MIXER_STATUS
985 MMixerAddMixerSourceLines(
986 IN PMIXER_CONTEXT MixerContext,
987 IN OUT LPMIXER_INFO MixerInfo,
988 IN PTOPOLOGY Topology,
989 IN ULONG DestinationLineID,
990 IN ULONG LineTerminator)
991 {
992 PULONG AllNodes, AllPins, AllPinNodes;
993 ULONG AllNodesCount, AllPinsCount, AllPinNodesCount;
994 ULONG Index, SubIndex, PinId, CurNode, bConnected;
995 MIXER_STATUS Status;
996 LPMIXERLINE_EXT DstLine, SrcLine;
997
998 /* get destination line */
999 DstLine = MMixerGetSourceMixerLineByLineId(MixerInfo, DestinationLineID);
1000 ASSERT(DstLine);
1001
1002 /* allocate an array to store all nodes which are upstream of the line terminator */
1003 Status = MMixerAllocateTopologyNodeArray(MixerContext, Topology, &AllNodes);
1004
1005 /* check for success */
1006 if (Status != MM_STATUS_SUCCESS)
1007 {
1008 /* out of memory */
1009 return MM_STATUS_NO_MEMORY;
1010 }
1011
1012 /* allocate an array to store all nodes which are downstream of a particular pin */
1013 Status = MMixerAllocateTopologyNodeArray(MixerContext, Topology, &AllPinNodes);
1014
1015 /* allocate an array to store all pins which are upstream of this pin */
1016 Status = MMixerAllocateTopologyPinArray(MixerContext, Topology, &AllPins);
1017
1018 /* check for success */
1019 if (Status != MM_STATUS_SUCCESS)
1020 {
1021 /* out of memory */
1022 MixerContext->Free(AllNodes);
1023 return MM_STATUS_NO_MEMORY;
1024 }
1025
1026 /* get all nodes which indirectly / directly connect to this node */
1027 AllNodesCount = 0;
1028 MMixerGetAllUpOrDownstreamNodesFromNodeIndex(MixerContext, Topology, LineTerminator, TRUE, &AllNodesCount, AllNodes);
1029
1030 /* get all pins which indirectly / directly connect to this node */
1031 AllPinsCount = 0;
1032 MMixerGetAllUpOrDownstreamPinsFromNodeIndex(MixerContext, Topology, LineTerminator, TRUE, &AllPinsCount, AllPins);
1033
1034 DPRINT1("LineTerminator %lu\n", LineTerminator);
1035 DPRINT1("PinCount %lu\n", AllPinsCount);
1036 DPRINT1("AllNodesCount %lu\n", AllNodesCount);
1037
1038 /* now construct the source lines which are attached to the destination line */
1039 Index = AllPinsCount;
1040
1041 do
1042 {
1043 /* get current pin id */
1044 PinId = AllPins[Index - 1];
1045
1046 /* reset nodes count */
1047 AllPinNodesCount = 0;
1048
1049 /* now scan all nodes and add them to AllPinNodes array when they are connected to this pin */
1050 for(SubIndex = 0; SubIndex < AllNodesCount; SubIndex++)
1051 {
1052 /* get current node index */
1053 CurNode = AllNodes[SubIndex];
1054
1055 if (CurNode != MAXULONG && CurNode != LineTerminator)
1056 {
1057 /* check if that node is connected in some way to the current pin */
1058 Status = MMixerIsNodeConnectedToPin(MixerContext, Topology, CurNode, PinId, TRUE, &bConnected);
1059
1060 if (Status != MM_STATUS_SUCCESS)
1061 break;
1062
1063 if (bConnected)
1064 {
1065 /* it is connected */
1066 AllPinNodes[AllPinNodesCount] = CurNode;
1067 AllPinNodesCount++;
1068
1069 /* clear current index */
1070 AllNodes[SubIndex] = MAXULONG;
1071 }
1072 }
1073 }
1074
1075 /* decrement pin index */
1076 Index--;
1077
1078 if (AllPinNodesCount)
1079 {
1080 #ifdef MMIXER_DEBUG
1081 ULONG TempIndex;
1082 #endif
1083 /* now build the mixer source line */
1084 Status = MMixerBuildMixerSourceLine(MixerContext, MixerInfo, Topology, PinId, AllPinNodesCount, AllPinNodes, DestinationLineID, &SrcLine);
1085
1086 if (Status == MM_STATUS_SUCCESS)
1087 {
1088 /* insert into line list */
1089 InsertTailList(&MixerInfo->LineList, &SrcLine->Entry);
1090
1091 /* increment destination line count */
1092 DstLine->Line.cConnections++;
1093 #ifdef MMIXER_DEBUG
1094 DPRINT1("Adding PinId %lu AllPinNodesCount %lu to DestinationLine %lu\n", PinId, AllPinNodesCount, DestinationLineID);
1095 for(TempIndex = 0; TempIndex < AllPinNodesCount; TempIndex++)
1096 DPRINT1("NodeIndex %lu\n", AllPinNodes[TempIndex]);
1097 #endif
1098 }
1099 }
1100 else
1101 {
1102 #ifdef MMIXER_DEBUG
1103 DPRINT1("Discarding DestinationLineID %lu PinId %lu NO NODES!\n", DestinationLineID, PinId);
1104 #endif
1105 }
1106
1107 }while(Index != 0);
1108
1109 return MM_STATUS_SUCCESS;
1110 }
1111
1112
1113 MIXER_STATUS
1114 MMixerAddMixerControlsToDestinationLine(
1115 IN PMIXER_CONTEXT MixerContext,
1116 IN OUT LPMIXER_INFO MixerInfo,
1117 IN PTOPOLOGY Topology,
1118 IN ULONG PinId,
1119 IN ULONG bInput,
1120 IN ULONG DestinationLineId,
1121 OUT PULONG OutLineTerminator)
1122 {
1123 PULONG Nodes;
1124 ULONG NodesCount, LineTerminator;
1125 MIXER_STATUS Status;
1126 LPMIXERLINE_EXT DstLine;
1127
1128 /* allocate nodes index array */
1129 Status = MMixerAllocateTopologyNodeArray(MixerContext, Topology, &Nodes);
1130
1131 /* check for success */
1132 if (Status != MM_STATUS_SUCCESS)
1133 {
1134 /* out of memory */
1135 return MM_STATUS_NO_MEMORY;
1136 }
1137
1138 /* get all destination line controls */
1139 Status = MMixerCountMixerControls(MixerContext, Topology, PinId, bInput, TRUE, &NodesCount, Nodes, &LineTerminator);
1140
1141 /* check for success */
1142 if (Status != MM_STATUS_SUCCESS)
1143 {
1144 /* failed to count controls */
1145 MixerContext->Free(Nodes);
1146 return Status;
1147 }
1148
1149 /* get destination mixer line */
1150 DstLine = MMixerGetSourceMixerLineByLineId(MixerInfo, DestinationLineId);
1151
1152 /* sanity check */
1153 ASSERT(DstLine);
1154
1155 if (NodesCount > 0)
1156 {
1157 /* add all nodes as mixer controls to the destination line */
1158 Status = MMixerAddMixerControlsToMixerLineByNodeIndexArray(MixerContext, MixerInfo, Topology, DstLine, NodesCount, Nodes);
1159 if (Status != MM_STATUS_SUCCESS)
1160 {
1161 /* failed to add controls */
1162 MixerContext->Free(Nodes);
1163 return Status;
1164 }
1165 }
1166
1167 /* store result */
1168 *OutLineTerminator = LineTerminator;
1169
1170 /* return result */
1171 return Status;
1172 }
1173
1174 VOID
1175 MMixerApplyOutputFilterHack(
1176 IN PMIXER_CONTEXT MixerContext,
1177 IN LPMIXER_DATA MixerData,
1178 IN OUT PULONG PinsCount,
1179 IN OUT PULONG Pins)
1180 {
1181 ULONG Count = 0, Index;
1182 MIXER_STATUS Status;
1183 PKSPIN_PHYSICALCONNECTION Connection;
1184
1185 for(Index = 0; Index < *PinsCount; Index++)
1186 {
1187 /* check if it has a physical connection */
1188 Status = MMixerGetPhysicalConnection(MixerContext, MixerData->hDevice, Pins[Index], &Connection);
1189
1190 if (Status == MM_STATUS_SUCCESS)
1191 {
1192 /* remove pin */
1193 MixerContext->Copy(&Pins[Index], &Pins[Index + 1], (*PinsCount - (Index + 1)) * sizeof(ULONG));
1194
1195 /* free physical connection */
1196 MixerContext->Free(Connection);
1197
1198 /* decrement index */
1199 Index--;
1200
1201 /* decrement pin count */
1202 (*PinsCount)--;
1203 }
1204 else
1205 {
1206 /* simple pin */
1207 Count++;
1208 }
1209 }
1210
1211 /* store result */
1212 *PinsCount = Count;
1213 }
1214
1215 MIXER_STATUS
1216 MMixerHandlePhysicalConnection(
1217 IN PMIXER_CONTEXT MixerContext,
1218 IN PMIXER_LIST MixerList,
1219 IN LPMIXER_DATA MixerData,
1220 IN OUT LPMIXER_INFO MixerInfo,
1221 IN ULONG bInput,
1222 IN PKSPIN_PHYSICALCONNECTION OutConnection)
1223 {
1224 MIXER_STATUS Status;
1225 ULONG PinsCount, LineTerminator, DestinationLineID;
1226 PULONG Pins;
1227 PTOPOLOGY Topology;
1228
1229 /* first try to open the connected filter */
1230 OutConnection->SymbolicLinkName[1] = L'\\';
1231 MixerData = MMixerGetDataByDeviceName(MixerList, OutConnection->SymbolicLinkName);
1232
1233 /* check if the linked connection is found */
1234 if (!MixerData)
1235 {
1236 /* filter references invalid physical connection */
1237 return MM_STATUS_UNSUCCESSFUL;
1238 }
1239
1240 DPRINT1("Name %S, Pin %lu bInput %lu\n", OutConnection->SymbolicLinkName, OutConnection->Pin, bInput);
1241
1242 if (MixerInfo->hMixer != NULL)
1243 {
1244 /* dont replace mixer destination handles */
1245 DPRINT1("MixerInfo hDevice %p MixerData hDevice %p\n", MixerInfo->hMixer, MixerData->hDevice);
1246 ASSERT(MixerInfo->hMixer == MixerData->hDevice);
1247 }
1248
1249 /* store connected mixer handle */
1250 MixerInfo->hMixer = MixerData->hDevice;
1251
1252 if (MixerData->Topology == NULL)
1253 {
1254 /* construct new topology */
1255 Status = MMixerBuildTopology(MixerContext, MixerData, &Topology);
1256 if (Status != MM_STATUS_SUCCESS)
1257 {
1258 /* failed to create topology */
1259 return Status;
1260 }
1261
1262 /* store topology */
1263 MixerData->Topology = Topology;
1264 }
1265 else
1266 {
1267 /* re-use existing topology */
1268 Topology = MixerData->Topology;
1269 }
1270
1271 /* allocate pin index array which will hold all referenced pins */
1272 Status = MMixerAllocateTopologyPinArray(MixerContext, Topology, &Pins);
1273 ASSERT(Status == MM_STATUS_SUCCESS);
1274
1275 if (!bInput)
1276 {
1277 /* the mixer is an output mixer
1278 * find end pin of the node path
1279 */
1280 PinsCount = 0;
1281 Status = MMixerGetAllUpOrDownstreamPinsFromPinIndex(MixerContext, Topology, OutConnection->Pin, FALSE, &PinsCount, Pins);
1282
1283 /* check for success */
1284 if (Status != MM_STATUS_SUCCESS)
1285 {
1286 /* failed to get end pin */
1287 MixerContext->Free(Pins);
1288 //MMixerFreeTopology(Topology);
1289
1290 /* return error code */
1291 return Status;
1292 }
1293 /* HACK:
1294 * some topologies do not have strict boundaries
1295 * WorkArround: remove all pin ids which have a physical connection
1296 * because bridge pins may belong to different render paths
1297 */
1298 MMixerApplyOutputFilterHack(MixerContext, MixerData, &PinsCount, Pins);
1299
1300 /* sanity checks */
1301 ASSERT(PinsCount != 0);
1302 ASSERT(PinsCount == 1);
1303
1304 /* create destination line */
1305 Status = MMixerBuildMixerDestinationLine(MixerContext, MixerInfo, Pins[0], bInput);
1306
1307 /* calculate destination line id */
1308 DestinationLineID = (DESTINATION_LINE + MixerInfo->MixCaps.cDestinations-1);
1309
1310 if (Status != MM_STATUS_SUCCESS)
1311 {
1312 /* failed to build destination line */
1313 MixerContext->Free(Pins);
1314
1315 /* return error code */
1316 return Status;
1317 }
1318
1319 /* add mixer controls to destination line */
1320 Status = MMixerAddMixerControlsToDestinationLine(MixerContext, MixerInfo, Topology, Pins[0], bInput, DestinationLineID, &LineTerminator);
1321
1322 if (Status == MM_STATUS_SUCCESS)
1323 {
1324 /* now add the rest of the source lines */
1325 Status = MMixerAddMixerSourceLines(MixerContext, MixerInfo, Topology, DestinationLineID, LineTerminator);
1326 }
1327 }
1328 else
1329 {
1330 /* calculate destination line id */
1331 DestinationLineID = (DESTINATION_LINE + MixerInfo->MixCaps.cDestinations-1);
1332
1333 /* add mixer controls */
1334 Status = MMixerAddMixerControlsToDestinationLine(MixerContext, MixerInfo, Topology, OutConnection->Pin, bInput, DestinationLineID, &LineTerminator);
1335
1336 if (Status == MM_STATUS_SUCCESS)
1337 {
1338 /* now add the rest of the source lines */
1339 Status = MMixerAddMixerSourceLines(MixerContext, MixerInfo, Topology, DestinationLineID, LineTerminator);
1340 }
1341 }
1342
1343 return Status;
1344 }
1345
1346 MIXER_STATUS
1347 MMixerInitializeFilter(
1348 IN PMIXER_CONTEXT MixerContext,
1349 IN PMIXER_LIST MixerList,
1350 IN LPMIXER_DATA MixerData,
1351 IN LPMIXER_INFO MixerInfo,
1352 IN PTOPOLOGY Topology,
1353 IN ULONG NodeIndex,
1354 IN ULONG bInputMixer,
1355 IN OUT LPMIXER_INFO * OutMixerInfo)
1356 {
1357
1358 MIXER_STATUS Status;
1359 PKSPIN_PHYSICALCONNECTION OutConnection;
1360 ULONG * Pins;
1361 ULONG PinsFound;
1362 ULONG NewMixerInfo = FALSE;
1363
1364 if (MixerInfo == NULL)
1365 {
1366 /* allocate a mixer info struct */
1367 MixerInfo = (LPMIXER_INFO) MixerContext->Alloc(sizeof(MIXER_INFO));
1368 if (!MixerInfo)
1369 {
1370 /* no memory */
1371 return MM_STATUS_NO_MEMORY;
1372 }
1373
1374 /* new mixer info */
1375 NewMixerInfo = TRUE;
1376
1377 /* intialize mixer caps */
1378 MixerInfo->MixCaps.wMid = MM_MICROSOFT; /* FIXME */
1379 MixerInfo->MixCaps.wPid = MM_PID_UNMAPPED; /* FIXME */
1380 MixerInfo->MixCaps.vDriverVersion = 1; /* FIXME */
1381 MixerInfo->MixCaps.fdwSupport = 0;
1382 MixerInfo->MixCaps.cDestinations = 0;
1383
1384 /* get mixer name */
1385 MMixerGetDeviceName(MixerContext, MixerInfo->MixCaps.szPname, MixerData->hDeviceInterfaceKey);
1386
1387 /* initialize line list */
1388 InitializeListHead(&MixerInfo->LineList);
1389 InitializeListHead(&MixerInfo->EventList);
1390 }
1391
1392 /* store mixer info */
1393 *OutMixerInfo = MixerInfo;
1394
1395 /* now allocate an array which will receive the indices of the pin
1396 * which has a ADC / DAC nodetype in its path
1397 */
1398 Status = MMixerAllocateTopologyPinArray(MixerContext, Topology, &Pins);
1399 ASSERT(Status == MM_STATUS_SUCCESS);
1400
1401 PinsFound = 0;
1402
1403 /* now get all sink / source pins, which are attached to the ADC / DAC node
1404 * For sink pins (wave out) search up stream
1405 * For source pins (wave in) search down stream
1406 * The search direction is always the opposite of the current mixer type
1407 */
1408 PinsFound = 0;
1409 MMixerGetAllUpOrDownstreamPinsFromNodeIndex(MixerContext, Topology, NodeIndex, !bInputMixer, &PinsFound, Pins);
1410
1411 /* if there is no pin found, we have a broken topology */
1412 ASSERT(PinsFound != 0);
1413
1414 /* now create a wave info struct */
1415 Status = MMixerInitializeWaveInfo(MixerContext, MixerList, MixerData, MixerInfo->MixCaps.szPname, bInputMixer, PinsFound, Pins);
1416 if (Status != MM_STATUS_SUCCESS)
1417 {
1418 /* failed to create wave info struct */
1419 MixerContext->Free(MixerInfo);
1420 MixerContext->Free(Pins);
1421 return Status;
1422 }
1423
1424 if (bInputMixer)
1425 {
1426 /* pre create the mixer destination line for input mixers */
1427 Status = MMixerBuildMixerDestinationLine(MixerContext, MixerInfo, Pins[0], bInputMixer);
1428
1429 if (Status != MM_STATUS_SUCCESS)
1430 {
1431 /* failed to create mixer destination line */
1432 return Status;
1433 }
1434 }
1435
1436
1437 /* now get the bridge pin which is at the end of node path
1438 * For sink pins (wave out) search down stream
1439 * For source pins (wave in) search up stream
1440 */
1441 MixerContext->Free(Pins);
1442 Status = MMixerAllocateTopologyPinArray(MixerContext, Topology, &Pins);
1443 ASSERT(Status == MM_STATUS_SUCCESS);
1444
1445 PinsFound = 0;
1446 MMixerGetAllUpOrDownstreamPinsFromNodeIndex(MixerContext, Topology, NodeIndex, bInputMixer, &PinsFound, Pins);
1447
1448 /* if there is no pin found, we have a broken topology */
1449 ASSERT(PinsFound != 0);
1450
1451 /* there should be exactly one bridge pin */
1452 ASSERT(PinsFound == 1);
1453
1454 DPRINT("BridgePin %lu bInputMixer %lu\n", Pins[0], bInputMixer);
1455
1456 /* does the pin have a physical connection */
1457 Status = MMixerGetPhysicalConnection(MixerContext, MixerData->hDevice, Pins[0], &OutConnection);
1458
1459 if (Status == MM_STATUS_SUCCESS)
1460 {
1461 /* topology on the topoloy filter */
1462 Status = MMixerHandlePhysicalConnection(MixerContext, MixerList, MixerData, MixerInfo, bInputMixer, OutConnection);
1463
1464 /* free physical connection data */
1465 MixerContext->Free(OutConnection);
1466 }
1467 else
1468 {
1469 /* FIXME
1470 * handle drivers which expose their topology on the same filter
1471 */
1472 ASSERT(0);
1473 MixerInfo->hMixer = MixerData->hDevice;
1474 }
1475
1476 /* free pins */
1477 MixerContext->Free(Pins);
1478
1479 if (NewMixerInfo)
1480 {
1481 /* insert mixer */
1482 InsertHeadList(&MixerList->MixerList, &MixerInfo->Entry);
1483 /* increment mixer count */
1484 MixerList->MixerListCount++;
1485 }
1486
1487 /* done */
1488 return Status;
1489 }
1490
1491 MIXER_STATUS
1492 MMixerSetupFilter(
1493 IN PMIXER_CONTEXT MixerContext,
1494 IN PMIXER_LIST MixerList,
1495 IN LPMIXER_DATA MixerData,
1496 IN PULONG DeviceCount)
1497 {
1498 MIXER_STATUS Status;
1499 PTOPOLOGY Topology;
1500 ULONG NodeIndex;
1501 LPMIXER_INFO MixerInfo = NULL;
1502
1503 /* check if topology has already been built */
1504 if (MixerData->Topology == NULL)
1505 {
1506 /* build topology */
1507 Status = MMixerBuildTopology(MixerContext, MixerData, &Topology);
1508
1509 if (Status != MM_STATUS_SUCCESS)
1510 {
1511 /* failed to build topology */
1512 return Status;
1513 }
1514
1515 /* store topology */
1516 MixerData->Topology = Topology;
1517 }
1518 else
1519 {
1520 /* re-use topology */
1521 Topology = MixerData->Topology;
1522 }
1523
1524 /* check if the filter has an wave out node */
1525 NodeIndex = MMixerGetNodeIndexFromGuid(Topology, &KSNODETYPE_DAC);
1526 if (NodeIndex != MAXULONG)
1527 {
1528 /* it has */
1529 Status = MMixerInitializeFilter(MixerContext, MixerList, MixerData, NULL, Topology, NodeIndex, FALSE, &MixerInfo);
1530
1531 /* check for success */
1532 if (Status == MM_STATUS_SUCCESS)
1533 {
1534 /* increment mixer count */
1535 (*DeviceCount)++;
1536 }
1537 else
1538 {
1539 /* reset mixer info in case of error */
1540 MixerInfo = NULL;
1541 }
1542 }
1543
1544 /* check if the filter has an wave in node */
1545 NodeIndex = MMixerGetNodeIndexFromGuid(Topology, &KSNODETYPE_ADC);
1546 if (NodeIndex != MAXULONG)
1547 {
1548 /* it has */
1549 Status = MMixerInitializeFilter(MixerContext, MixerList, MixerData, MixerInfo, Topology, NodeIndex, TRUE, &MixerInfo);
1550
1551 /* check for success */
1552 if (Status == MM_STATUS_SUCCESS)
1553 {
1554 /* increment mixer count */
1555 (*DeviceCount)++;
1556 }
1557
1558 }
1559
1560 /* TODO: handle alternative mixer types + apply hacks for Wave source line */
1561
1562 /* activate midi devices */
1563 MMixerInitializeMidiForFilter(MixerContext, MixerList, MixerData, Topology);
1564
1565 /* done */
1566 return Status;
1567 }
1568
1569
1570 MIXER_STATUS
1571 MMixerAddEvent(
1572 IN PMIXER_CONTEXT MixerContext,
1573 IN OUT LPMIXER_INFO MixerInfo,
1574 IN PVOID MixerEventContext,
1575 IN PMIXER_EVENT MixerEventRoutine)
1576 {
1577 //KSE_NODE Property;
1578 PEVENT_NOTIFICATION_ENTRY EventData;
1579 //ULONG BytesReturned;
1580 //MIXER_STATUS Status;
1581
1582 EventData = (PEVENT_NOTIFICATION_ENTRY)MixerContext->AllocEventData(sizeof(EVENT_NOTIFICATION_ENTRY));
1583 if (!EventData)
1584 {
1585 /* not enough memory */
1586 return MM_STATUS_NO_MEMORY;
1587 }
1588
1589 #if 0
1590 /* setup request */
1591 Property.Event.Set = KSEVENTSETID_AudioControlChange;
1592 Property.Event.Flags = KSEVENT_TYPE_TOPOLOGY|KSEVENT_TYPE_ENABLE;
1593 Property.Event.Id = KSEVENT_CONTROL_CHANGE;
1594
1595 Property.NodeId = NodeId;
1596 Property.Reserved = 0;
1597
1598 Status = MixerContext->Control(MixerInfo->hMixer, IOCTL_KS_ENABLE_EVENT, (PVOID)&Property, sizeof(KSP_NODE), (PVOID)EventData, sizeof(KSEVENTDATA), &BytesReturned);
1599 if (Status != MM_STATUS_SUCCESS)
1600 {
1601 /* failed to add event */
1602 MixerContext->FreeEventData(EventData);
1603 return Status;
1604 }
1605 #endif
1606
1607 /* initialize notification entry */
1608 EventData->MixerEventContext = MixerEventContext;
1609 EventData->MixerEventRoutine;
1610
1611 /* store event */
1612 InsertTailList(&MixerInfo->EventList, &EventData->Entry);
1613 return MM_STATUS_SUCCESS;
1614 }
1615