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