reactos/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 MIXER_STATUS
  12 MMixerGetTargetPinsByNodeConnectionIndex(
  13     IN PMIXER_CONTEXT MixerContext,
  14     IN PKSMULTIPLE_ITEM NodeConnections,
  15     IN PKSMULTIPLE_ITEM NodeTypes,
  16     IN ULONG bUpDirection,
  17     IN ULONG NodeConnectionIndex,
  18     OUT PULONG Pins)
  19 {
  20     PKSTOPOLOGY_CONNECTION Connection;
  21     ULONG PinId, NodeConnectionCount, Index;
  22     PULONG NodeConnection;
  23     MIXER_STATUS Status;
  24
  25
  26     /* sanity check */
  27     ASSERT(NodeConnectionIndex < NodeConnections->Count);
  28
  29     Connection = (PKSTOPOLOGY_CONNECTION)(NodeConnections + 1);
  30
  31     //DPRINT("FromNode %u FromNodePin %u -> ToNode %u ToNodePin %u\n", Connection[NodeConnectionIndex].FromNode, Connection[NodeConnectionIndex].FromNodePin, Connection[NodeConnectionIndex].ToNode, Connection[NodeConnectionIndex].ToNodePin );
  32
  33     if ((Connection[NodeConnectionIndex].ToNode == KSFILTER_NODE && bUpDirection == FALSE) ||
  34         (Connection[NodeConnectionIndex].FromNode == KSFILTER_NODE && bUpDirection == TRUE))
  35     {
  36         /* iteration stops here */
  37        if (bUpDirection)
  38            PinId = Connection[NodeConnectionIndex].FromNodePin;
  39        else
  40            PinId = Connection[NodeConnectionIndex].ToNodePin;
  41
  42        //DPRINT("GetTargetPinsByNodeIndex FOUND Target Pin %u Parsed %u\n", PinId, Pins[PinId]);
  43
  44        /* mark pin index as a target pin */
  45        Pins[PinId] = TRUE;
  46        return MM_STATUS_SUCCESS;
  47     }
  48
  49     // get all node indexes referenced by that node
  50     if (bUpDirection)
  51     {
  52         Status = MMixerGetNodeIndexes(MixerContext, NodeConnections, Connection[NodeConnectionIndex].FromNode, TRUE, FALSE, &NodeConnectionCount, &NodeConnection);
  53     }
  54     else
  55     {
  56         Status = MMixerGetNodeIndexes(MixerContext, NodeConnections, Connection[NodeConnectionIndex].ToNode, TRUE, TRUE, &NodeConnectionCount, &NodeConnection);
  57     }
  58
  59     if (Status == MM_STATUS_SUCCESS)
  60     {
  61         for(Index = 0; Index < NodeConnectionCount; Index++)
  62         {
  63             // iterate recursively into the nodes
  64             Status = MMixerGetTargetPinsByNodeConnectionIndex(MixerContext, NodeConnections, NodeTypes, bUpDirection, NodeConnection[Index], Pins);
  65             ASSERT(Status == MM_STATUS_SUCCESS);
  66         }
  67         // free node connection indexes
  68         MixerContext->Free(NodeConnection);
  69     }
  70
  71     return Status;
  72 }
  73
  74 MIXER_STATUS
  75 MMixerGetControlsFromPinByConnectionIndex(
  76     IN PMIXER_CONTEXT MixerContext,
  77     IN PKSMULTIPLE_ITEM NodeConnections,
  78     IN PKSMULTIPLE_ITEM NodeTypes,
  79     IN ULONG bUpDirection,
  80     IN ULONG NodeConnectionIndex,
  81     OUT PULONG Nodes)
  82 {
  83     PKSTOPOLOGY_CONNECTION CurConnection;
  84     LPGUID NodeType;
  85     ULONG NodeIndex;
  86     MIXER_STATUS Status;
  87     ULONG NodeConnectionCount, Index;
  88     PULONG NodeConnection;
  89
  90
  91     /* get current connection */
  92     CurConnection = MMixerGetConnectionByIndex(NodeConnections, NodeConnectionIndex);
  93
  94     if (bUpDirection)
  95         NodeIndex = CurConnection->FromNode;
  96     else
  97         NodeIndex = CurConnection->ToNode;
  98
  99     if (NodeIndex > NodeTypes->Count)
 100     {
 101         // reached end of pin connection
 102         return MM_STATUS_SUCCESS;
 103     }
 104
 105     /* get target node type of current connection */
 106     NodeType = MMixerGetNodeType(NodeTypes, NodeIndex);
 107
 108     if (IsEqualGUIDAligned(NodeType, &KSNODETYPE_SUM) || IsEqualGUIDAligned(NodeType, &KSNODETYPE_MUX))
 109     {
 110         if (bUpDirection)
 111         {
 112             /* add the sum / mux node to destination line */
 113             Nodes[NodeIndex] = TRUE;
 114         }
 115
 116         return MM_STATUS_SUCCESS;
 117     }
 118
 119     /* now add the node */
 120     Nodes[NodeIndex] = TRUE;
 121
 122
 123     /* get all node indexes referenced by that node */
 124     if (bUpDirection)
 125     {
 126         Status = MMixerGetNodeIndexes(MixerContext, NodeConnections, NodeIndex, TRUE, FALSE, &NodeConnectionCount, &NodeConnection);
 127     }
 128     else
 129     {
 130         Status = MMixerGetNodeIndexes(MixerContext, NodeConnections, NodeIndex, TRUE, TRUE, &NodeConnectionCount, &NodeConnection);
 131     }
 132
 133     if (Status == MM_STATUS_SUCCESS)
 134     {
 135         for(Index = 0; Index < NodeConnectionCount; Index++)
 136         {
 137             /* iterate recursively into the nodes */
 138             Status = MMixerGetControlsFromPinByConnectionIndex(MixerContext, NodeConnections, NodeTypes, bUpDirection, NodeConnection[Index], Nodes);
 139             ASSERT(Status == MM_STATUS_SUCCESS);
 140         }
 141         /* free node connection indexes */
 142         MixerContext->Free(NodeConnection);
 143     }
 144
 145     return Status;
 146 }
 147
 148 MIXER_STATUS
 149 MMixerAddMixerControl(
 150     IN PMIXER_CONTEXT MixerContext,
 151     IN LPMIXER_INFO MixerInfo,
 152     IN HANDLE hDevice,
 153     IN PKSMULTIPLE_ITEM NodeTypes,
 154     IN ULONG NodeIndex,
 155     IN LPMIXERLINE_EXT MixerLine,
 156     OUT LPMIXERCONTROLW MixerControl)
 157 {
 158     LPGUID NodeType;
 159     KSP_NODE Node;
 160     ULONG BytesReturned;
 161     MIXER_STATUS Status;
 162     LPWSTR Name;
 163
 164     /* initialize mixer control */
 165     MixerControl->cbStruct = sizeof(MIXERCONTROLW);
 166     MixerControl->dwControlID = MixerInfo->ControlId;
 167
 168     /* get node type */
 169     NodeType = MMixerGetNodeType(NodeTypes, NodeIndex);
 170     /* store control type */
 171     MixerControl->dwControlType = MMixerGetControlTypeFromTopologyNode(NodeType);
 172
 173     MixerControl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM; //FIXME
 174     MixerControl->cMultipleItems = 0; //FIXME
 175
 176     if (MixerControl->dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE)
 177     {
 178         MixerControl->Bounds.dwMinimum = 0;
 179         MixerControl->Bounds.dwMaximum = 1;
 180     }
 181     else if (MixerControl->dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME)
 182     {
 183         MixerControl->Bounds.dwMinimum = 0;
 184         MixerControl->Bounds.dwMaximum = 0xFFFF;
 185         MixerControl->Metrics.cSteps = 0xC0; //FIXME
 186     }
 187
 188     /* setup request to retrieve name */
 189     Node.NodeId = NodeIndex;
 190     Node.Property.Id = KSPROPERTY_TOPOLOGY_NAME;
 191     Node.Property.Flags = KSPROPERTY_TYPE_GET;
 192     Node.Property.Set = KSPROPSETID_Topology;
 193     Node.Reserved = 0;
 194
 195     /* get node name size */
 196     Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&Node, sizeof(KSP_NODE), NULL, 0, &BytesReturned);
 197
 198     if (Status == MM_STATUS_MORE_ENTRIES)
 199     {
 200         ASSERT(BytesReturned != 0);
 201         Name = (LPWSTR)MixerContext->Alloc(BytesReturned);
 202         if (!Name)
 203         {
 204             /* not enough memory */
 205             return MM_STATUS_NO_MEMORY;
 206         }
 207
 208         /* get node name */
 209         Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&Node, sizeof(KSP_NODE), (LPVOID)Name, BytesReturned, &BytesReturned);
 210         if (Status != MM_STATUS_SUCCESS)
 211         {
 212             MixerContext->Copy(MixerControl->szShortName, Name, (min(MIXER_SHORT_NAME_CHARS, wcslen(Name)+1)) * sizeof(WCHAR));
 213             MixerControl->szShortName[MIXER_SHORT_NAME_CHARS-1] = L'\0';
 214
 215             MixerContext->Copy(MixerControl->szName, Name, (min(MIXER_LONG_NAME_CHARS, wcslen(Name)+1)) * sizeof(WCHAR));
 216             MixerControl->szName[MIXER_LONG_NAME_CHARS-1] = L'\0';
 217         }
 218
 219         /* free name buffer */
 220         MixerContext->Free(Name);
 221     }
 222
 223     MixerInfo->ControlId++;
 224 #if 0
 225     if (MixerControl->dwControlType == MIXERCONTROL_CONTROLTYPE_MUX)
 226     {
 227         KSNODEPROPERTY Property;
 228         ULONG PinId = 2;
 229
 230         /* setup the request */
 231         RtlZeroMemory(&Property, sizeof(KSNODEPROPERTY));
 232
 233         Property.NodeId = NodeIndex;
 234         Property.Property.Id = KSPROPERTY_AUDIO_MUX_SOURCE;
 235         Property.Property.Flags = KSPROPERTY_TYPE_SET;
 236         Property.Property.Set = KSPROPSETID_Audio;
 237
 238         /* get node volume level info */
 239         Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSNODEPROPERTY), (PVOID)&PinId, sizeof(ULONG), &BytesReturned);
 240
 241         DPRINT1("Status %x NodeIndex %u PinId %u\n", Status, NodeIndex, PinId);
 242         //DbgBreakPoint();
 243     }else
 244 #endif
 245     if (MixerControl->dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME)
 246     {
 247         KSNODEPROPERTY_AUDIO_CHANNEL Property;
 248         ULONG Length;
 249         PKSPROPERTY_DESCRIPTION Desc;
 250         PKSPROPERTY_MEMBERSHEADER Members;
 251         PKSPROPERTY_STEPPING_LONG Range;
 252
 253         Length = sizeof(KSPROPERTY_DESCRIPTION) + sizeof(KSPROPERTY_MEMBERSHEADER) + sizeof(KSPROPERTY_STEPPING_LONG);
 254         Desc = (PKSPROPERTY_DESCRIPTION)MixerContext->Alloc(Length);
 255         ASSERT(Desc);
 256
 257         /* setup the request */
 258         RtlZeroMemory(&Property, sizeof(KSNODEPROPERTY_AUDIO_CHANNEL));
 259
 260         Property.NodeProperty.NodeId = NodeIndex;
 261         Property.NodeProperty.Property.Id = KSPROPERTY_AUDIO_VOLUMELEVEL;
 262         Property.NodeProperty.Property.Flags = KSPROPERTY_TYPE_BASICSUPPORT;
 263         Property.NodeProperty.Property.Set = KSPROPSETID_Audio;
 264
 265         /* get node volume level info */
 266         Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSNODEPROPERTY_AUDIO_CHANNEL), Desc, Length, &BytesReturned);
 267
 268         if (Status == MM_STATUS_SUCCESS)
 269         {
 270             LPMIXERVOLUME_DATA VolumeData;
 271             ULONG Steps, MaxRange, Index;
 272             LONG Value;
 273
 274             Members = (PKSPROPERTY_MEMBERSHEADER)(Desc + 1);
 275             Range = (PKSPROPERTY_STEPPING_LONG)(Members + 1);
 276
 277             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);
 278
 279             MaxRange = Range->Bounds.UnsignedMaximum  - Range->Bounds.UnsignedMinimum;
 280
 281             if (MaxRange)
 282             {
 283                 ASSERT(MaxRange);
 284                 VolumeData = (LPMIXERVOLUME_DATA)MixerContext->Alloc(sizeof(MIXERVOLUME_DATA));
 285                 if (!VolumeData)
 286                     return MM_STATUS_NO_MEMORY;
 287
 288                 Steps = MaxRange / Range->SteppingDelta + 1;
 289
 290                 /* store mixer control info there */
 291                 VolumeData->Header.dwControlID = MixerControl->dwControlID;
 292                 VolumeData->SignedMaximum = Range->Bounds.SignedMaximum;
 293                 VolumeData->SignedMinimum = Range->Bounds.SignedMinimum;
 294                 VolumeData->SteppingDelta = Range->SteppingDelta;
 295                 VolumeData->ValuesCount = Steps;
 296                 VolumeData->InputSteppingDelta = 0x10000 / Steps;
 297
 298                 VolumeData->Values = (PLONG)MixerContext->Alloc(sizeof(LONG) * Steps);
 299                 if (!VolumeData->Values)
 300                 {
 301                     MixerContext->Free(Desc);
 302                     MixerContext->Free(VolumeData);
 303
 304                     return MM_STATUS_NO_MEMORY;
 305                 }
 306
 307                 Value = Range->Bounds.SignedMinimum;
 308                 for(Index = 0; Index < Steps; Index++)
 309                 {
 310                     VolumeData->Values[Index] = Value;
 311                     Value += Range->SteppingDelta;
 312                 }
 313                 InsertTailList(&MixerLine->LineControlsExtraData, &VolumeData->Header.Entry);
 314            }
 315        }
 316        MixerContext->Free(Desc);
 317     }
 318
 319
 320     DPRINT("Status %x Name %S\n", Status, MixerControl->szName);
 321     return MM_STATUS_SUCCESS;
 322 }
 323
 324 MIXER_STATUS
 325 MMixerAddMixerSourceLine(
 326     IN PMIXER_CONTEXT MixerContext,
 327     IN OUT LPMIXER_INFO MixerInfo,
 328     IN HANDLE hDevice,
 329     IN PKSMULTIPLE_ITEM NodeConnections,
 330     IN PKSMULTIPLE_ITEM NodeTypes,
 331     IN ULONG PinId,
 332     IN ULONG bBridgePin,
 333     IN ULONG bTargetPin)
 334 {
 335     LPMIXERLINE_EXT SrcLine, DstLine;
 336     MIXER_STATUS Status;
 337     KSP_PIN Pin;
 338     LPWSTR PinName;
 339     GUID NodeType;
 340     ULONG BytesReturned, ControlCount, Index;
 341     LPGUID Node;
 342     PULONG Nodes;
 343
 344     if (!bTargetPin)
 345     {
 346         /* allocate src mixer line */
 347         SrcLine = (LPMIXERLINE_EXT)MixerContext->Alloc(sizeof(MIXERLINE_EXT));
 348
 349         if (!SrcLine)
 350             return MM_STATUS_NO_MEMORY;
 351
 352         /* zero struct */
 353         RtlZeroMemory(SrcLine, sizeof(MIXERLINE_EXT));
 354
 355     }
 356     else
 357     {
 358         ASSERT(!IsListEmpty(&MixerInfo->LineList));
 359         SrcLine = MMixerGetSourceMixerLineByLineId(MixerInfo, DESTINATION_LINE);
 360     }
 361
 362     /* get destination line */
 363     DstLine = MMixerGetSourceMixerLineByLineId(MixerInfo, DESTINATION_LINE);
 364     ASSERT(DstLine);
 365
 366
 367     if (!bTargetPin)
 368     {
 369         /* initialize mixer src line */
 370         SrcLine->hDevice = hDevice;
 371         SrcLine->PinId = PinId;
 372         SrcLine->Line.cbStruct = sizeof(MIXERLINEW);
 373
 374         /* initialize mixer destination line */
 375         SrcLine->Line.cbStruct = sizeof(MIXERLINEW);
 376         SrcLine->Line.dwDestination = 0;
 377         SrcLine->Line.dwSource = DstLine->Line.cConnections;
 378         SrcLine->Line.dwLineID = (DstLine->Line.cConnections * 0x10000);
 379         SrcLine->Line.fdwLine = MIXERLINE_LINEF_ACTIVE | MIXERLINE_LINEF_SOURCE;
 380         SrcLine->Line.dwUser = 0;
 381         SrcLine->Line.cChannels = DstLine->Line.cChannels;
 382         SrcLine->Line.cConnections = 0;
 383         SrcLine->Line.Target.dwType = 1;
 384         SrcLine->Line.Target.dwDeviceID = DstLine->Line.Target.dwDeviceID;
 385         SrcLine->Line.Target.wMid = MixerInfo->MixCaps.wMid;
 386         SrcLine->Line.Target.wPid = MixerInfo->MixCaps.wPid;
 387         SrcLine->Line.Target.vDriverVersion = MixerInfo->MixCaps.vDriverVersion;
 388         InitializeListHead(&SrcLine->LineControlsExtraData);
 389         wcscpy(SrcLine->Line.Target.szPname, MixerInfo->MixCaps.szPname);
 390
 391     }
 392
 393     /* allocate a node arrary */
 394     Nodes = (PULONG)MixerContext->Alloc(sizeof(ULONG) * NodeTypes->Count);
 395
 396     if (!Nodes)
 397     {
 398         /* not enough memory */
 399         if (!bTargetPin)
 400         {
 401             MixerContext->Free(SrcLine);
 402         }
 403         return MM_STATUS_NO_MEMORY;
 404     }
 405
 406     Status = MMixerGetControlsFromPin(MixerContext, NodeConnections, NodeTypes, PinId, bTargetPin, Nodes);
 407     if (Status != MM_STATUS_SUCCESS)
 408     {
 409         /* something went wrong */
 410         if (!bTargetPin)
 411         {
 412             MixerContext->Free(SrcLine);
 413         }
 414         MixerContext->Free(Nodes);
 415         return Status;
 416     }
 417
 418     /* now count all nodes controlled by that pin */
 419     ControlCount = 0;
 420     for(Index = 0; Index < NodeTypes->Count; Index++)
 421     {
 422         if (Nodes[Index])
 423         {
 424             // get node type
 425             Node = MMixerGetNodeType(NodeTypes, Index);
 426
 427             if (MMixerGetControlTypeFromTopologyNode(Node))
 428             {
 429                 // found a node which can be resolved to a type
 430                 ControlCount++;
 431             }
 432         }
 433     }
 434
 435     /* now allocate the line controls */
 436     if (ControlCount)
 437     {
 438         SrcLine->LineControls = (LPMIXERCONTROLW)MixerContext->Alloc(sizeof(MIXERCONTROLW) * ControlCount);
 439
 440         if (!SrcLine->LineControls)
 441         {
 442             /* no memory available */
 443             if (!bTargetPin)
 444             {
 445                 MixerContext->Free(SrcLine);
 446             }
 447             MixerContext->Free(Nodes);
 448             return MM_STATUS_NO_MEMORY;
 449         }
 450
 451         SrcLine->NodeIds = (PULONG)MixerContext->Alloc(sizeof(ULONG) * ControlCount);
 452         if (!SrcLine->NodeIds)
 453         {
 454             /* no memory available */
 455             MixerContext->Free(SrcLine->LineControls);
 456             if (!bTargetPin)
 457             {
 458                 MixerContext->Free(SrcLine);
 459             }
 460             MixerContext->Free(Nodes);
 461             return MM_STATUS_NO_MEMORY;
 462         }
 463
 464         /* zero line controls */
 465         RtlZeroMemory(SrcLine->LineControls, sizeof(MIXERCONTROLW) * ControlCount);
 466         RtlZeroMemory(SrcLine->NodeIds, sizeof(ULONG) * ControlCount);
 467
 468         ControlCount = 0;
 469         for(Index = 0; Index < NodeTypes->Count; Index++)
 470         {
 471             if (Nodes[Index])
 472             {
 473                 // get node type
 474                 Node = MMixerGetNodeType(NodeTypes, Index);
 475
 476                 if (MMixerGetControlTypeFromTopologyNode(Node))
 477                 {
 478                     /* store the node index for retrieving / setting details */
 479                     SrcLine->NodeIds[ControlCount] = Index;
 480
 481                     Status = MMixerAddMixerControl(MixerContext, MixerInfo, hDevice, NodeTypes, Index, SrcLine, &SrcLine->LineControls[ControlCount]);
 482                     if (Status == MM_STATUS_SUCCESS)
 483                     {
 484                         /* increment control count on success */
 485                         ControlCount++;
 486                     }
 487                 }
 488             }
 489         }
 490         /* store control count */
 491         SrcLine->Line.cControls = ControlCount;
 492     }
 493
 494     /* release nodes array */
 495     MixerContext->Free(Nodes);
 496
 497     /* get pin category */
 498     Pin.PinId = PinId;
 499     Pin.Reserved = 0;
 500     Pin.Property.Flags = KSPROPERTY_TYPE_GET;
 501     Pin.Property.Set = KSPROPSETID_Pin;
 502     Pin.Property.Id = KSPROPERTY_PIN_CATEGORY;
 503
 504     /* try get pin category */
 505     Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (LPVOID)&NodeType, sizeof(GUID), &BytesReturned);
 506     if (Status != MM_STATUS_SUCCESS)
 507     {
 508         //FIXME
 509         //map component type
 510     }
 511
 512     /* retrieve pin name */
 513     Pin.PinId = PinId;
 514     Pin.Reserved = 0;
 515     Pin.Property.Flags = KSPROPERTY_TYPE_GET;
 516     Pin.Property.Set = KSPROPSETID_Pin;
 517     Pin.Property.Id = KSPROPERTY_PIN_NAME;
 518
 519     /* try get pin name size */
 520     Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), NULL, 0, &BytesReturned);
 521
 522     if (Status == MM_STATUS_MORE_ENTRIES)
 523     {
 524         PinName = (LPWSTR)MixerContext->Alloc(BytesReturned);
 525         if (PinName)
 526         {
 527             /* try get pin name */
 528             Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (LPVOID)PinName, BytesReturned, &BytesReturned);
 529
 530             if (Status == MM_STATUS_SUCCESS)
 531             {
 532                 MixerContext->Copy(SrcLine->Line.szShortName, PinName, (min(MIXER_SHORT_NAME_CHARS, wcslen(PinName)+1)) * sizeof(WCHAR));
 533                 SrcLine->Line.szShortName[MIXER_SHORT_NAME_CHARS-1] = L'\0';
 534
 535                 MixerContext->Copy(SrcLine->Line.szName, PinName, (min(MIXER_LONG_NAME_CHARS, wcslen(PinName)+1)) * sizeof(WCHAR));
 536                 SrcLine->Line.szName[MIXER_LONG_NAME_CHARS-1] = L'\0';
 537             }
 538             MixerContext->Free(PinName);
 539         }
 540     }
 541
 542     /* insert src line */
 543     if (!bTargetPin)
 544     {
 545         InsertTailList(&MixerInfo->LineList, &SrcLine->Entry);
 546         DstLine->Line.cConnections++;
 547     }
 548
 549     return MM_STATUS_SUCCESS;
 550 }
 551
 552 MIXER_STATUS
 553 MMixerCreateDestinationLine(
 554     IN PMIXER_CONTEXT MixerContext,
 555     IN LPMIXER_INFO MixerInfo,
 556     IN ULONG bInputMixer,
 557     IN LPWSTR LineName)
 558 {
 559     LPMIXERLINE_EXT DestinationLine;
 560
 561     // allocate a mixer destination line
 562     DestinationLine = (LPMIXERLINE_EXT) MixerContext->Alloc(sizeof(MIXERLINE_EXT));
 563     if (!MixerInfo)
 564     {
 565         // no memory
 566         return MM_STATUS_NO_MEMORY;
 567     }
 568
 569     /* initialize mixer destination line */
 570     DestinationLine->Line.cbStruct = sizeof(MIXERLINEW);
 571     DestinationLine->Line.dwSource = MAXULONG;
 572     DestinationLine->Line.dwLineID = DESTINATION_LINE;
 573     DestinationLine->Line.fdwLine = MIXERLINE_LINEF_ACTIVE;
 574     DestinationLine->Line.dwUser = 0;
 575     DestinationLine->Line.dwComponentType = (bInputMixer == 0 ? MIXERLINE_COMPONENTTYPE_DST_SPEAKERS : MIXERLINE_COMPONENTTYPE_DST_WAVEIN);
 576     DestinationLine->Line.cChannels = 2; //FIXME
 577
 578     if (LineName)
 579     {
 580         wcscpy(DestinationLine->Line.szShortName, LineName);
 581         wcscpy(DestinationLine->Line.szName, LineName);
 582     }
 583     else
 584     {
 585         /* FIXME no name was found for pin */
 586         wcscpy(DestinationLine->Line.szShortName, L"Summe");
 587         wcscpy(DestinationLine->Line.szName, L"Summe");
 588     }
 589
 590     DestinationLine->Line.Target.dwType = (bInputMixer == 0 ? MIXERLINE_TARGETTYPE_WAVEOUT : MIXERLINE_TARGETTYPE_WAVEIN);
 591     DestinationLine->Line.Target.dwDeviceID = !bInputMixer;
 592     DestinationLine->Line.Target.wMid = MixerInfo->MixCaps.wMid;
 593     DestinationLine->Line.Target.wPid = MixerInfo->MixCaps.wPid;
 594     DestinationLine->Line.Target.vDriverVersion = MixerInfo->MixCaps.vDriverVersion;
 595     wcscpy(DestinationLine->Line.Target.szPname, MixerInfo->MixCaps.szPname);
 596
 597
 598     // insert into mixer info
 599     InsertHeadList(&MixerInfo->LineList, &DestinationLine->Entry);
 600
 601     // done
 602     return MM_STATUS_SUCCESS;
 603 }
 604
 605 MIXER_STATUS
 606 MMixerGetControlsFromPin(
 607     IN PMIXER_CONTEXT MixerContext,
 608     IN PKSMULTIPLE_ITEM NodeConnections,
 609     IN PKSMULTIPLE_ITEM NodeTypes,
 610     IN ULONG PinId,
 611     IN ULONG bUpDirection,
 612     OUT PULONG Nodes)
 613 {
 614     ULONG NodeConnectionCount, Index;
 615     MIXER_STATUS Status;
 616     PULONG NodeConnection;
 617
 618     /* sanity check */
 619     ASSERT(PinId != (ULONG)-1);
 620
 621     /* get all node indexes referenced by that pin */
 622     if (bUpDirection)
 623         Status = MMixerGetNodeIndexes(MixerContext, NodeConnections, PinId, FALSE, FALSE, &NodeConnectionCount, &NodeConnection);
 624     else
 625         Status = MMixerGetNodeIndexes(MixerContext, NodeConnections, PinId, FALSE, TRUE, &NodeConnectionCount, &NodeConnection);
 626
 627     for(Index = 0; Index < NodeConnectionCount; Index++)
 628     {
 629         /* get all associated controls */
 630         Status = MMixerGetControlsFromPinByConnectionIndex(MixerContext, NodeConnections, NodeTypes, bUpDirection, NodeConnection[Index], Nodes);
 631     }
 632
 633     MixerContext->Free(NodeConnection);
 634
 635     return Status;
 636 }
 637
 638
 639
 640
 641 MIXER_STATUS
 642 MMixerAddMixerSourceLines(
 643     IN PMIXER_CONTEXT MixerContext,
 644     IN OUT LPMIXER_INFO MixerInfo,
 645     IN HANDLE hDevice,
 646     IN PKSMULTIPLE_ITEM NodeConnections,
 647     IN PKSMULTIPLE_ITEM NodeTypes,
 648     IN ULONG PinsCount,
 649     IN ULONG BridgePinIndex,
 650     IN ULONG TargetPinIndex,
 651     IN PULONG Pins)
 652 {
 653     ULONG Index;
 654
 655     for(Index = PinsCount; Index > 0; Index--)
 656     {
 657         DPRINT("MMixerAddMixerSourceLines Index %lu Pin %lu\n", Index-1, Pins[Index-1]);
 658         if (Pins[Index-1])
 659         {
 660             MMixerAddMixerSourceLine(MixerContext, MixerInfo, hDevice, NodeConnections, NodeTypes, Index-1, (Index -1 == BridgePinIndex), (Index -1 == TargetPinIndex));
 661         }
 662     }
 663     return MM_STATUS_SUCCESS;
 664 }
 665
 666
 667 MIXER_STATUS
 668 MMixerHandlePhysicalConnection(
 669     IN PMIXER_CONTEXT MixerContext,
 670     IN OUT LPMIXER_INFO MixerInfo,
 671     IN ULONG bInput,
 672     IN PKSPIN_PHYSICALCONNECTION OutConnection)
 673 {
 674     PULONG PinsRef = NULL, PinConnectionIndex = NULL, PinsSrcRef;
 675     ULONG PinsRefCount, Index, PinConnectionIndexCount;
 676     MIXER_STATUS Status;
 677     HANDLE hDevice = NULL;
 678     PKSMULTIPLE_ITEM NodeTypes = NULL;
 679     PKSMULTIPLE_ITEM NodeConnections = NULL;
 680     PULONG MixerControls;
 681     ULONG MixerControlsCount;
 682
 683
 684     // open the connected filter
 685     Status = MixerContext->Open(OutConnection->SymbolicLinkName, &hDevice);
 686     if (Status != MM_STATUS_SUCCESS)
 687     {
 688         DPRINT("OpenDevice failed with %x\n", Status);
 689         return Status;
 690     }
 691
 692     // get connected filter pin count
 693     PinsRefCount = MMixerGetFilterPinCount(MixerContext, hDevice);
 694     ASSERT(PinsRefCount);
 695
 696     PinsRef = (PULONG)MixerContext->Alloc(sizeof(ULONG) * PinsRefCount);
 697     if (!PinsRef)
 698     {
 699         // no memory
 700         MixerContext->Close(hDevice);
 701         return MM_STATUS_UNSUCCESSFUL;
 702     }
 703
 704     // get topology node types
 705     Status = MMixerGetFilterTopologyProperty(MixerContext, hDevice, KSPROPERTY_TOPOLOGY_NODES, &NodeTypes);
 706     if (Status != MM_STATUS_SUCCESS)
 707     {
 708         MixerContext->Close(hDevice);
 709         MixerContext->Free(PinsRef);
 710         return Status;
 711     }
 712
 713     // get topology connections
 714     Status = MMixerGetFilterTopologyProperty(MixerContext, hDevice, KSPROPERTY_TOPOLOGY_CONNECTIONS, &NodeConnections);
 715     if (Status != MM_STATUS_SUCCESS)
 716     {
 717         MixerContext->Close(hDevice);
 718         MixerContext->Free(PinsRef);
 719         MixerContext->Free(NodeTypes);
 720         return Status;
 721     }
 722     //  gets connection index of the bridge pin which connects to a node
 723     DPRINT("Pin %lu\n", OutConnection->Pin);
 724
 725     Status = MMixerGetNodeIndexes(MixerContext, NodeConnections, OutConnection->Pin, FALSE, !bInput, &PinConnectionIndexCount, &PinConnectionIndex);
 726     if (Status != MM_STATUS_SUCCESS)
 727     {
 728         MixerContext->Close(hDevice);
 729         MixerContext->Free(PinsRef);
 730         MixerContext->Free(NodeTypes);
 731         MixerContext->Free(NodeConnections);
 732         return Status;
 733     }
 734
 735     /* there should be no split in the bride pin */
 736     ASSERT(PinConnectionIndexCount == 1);
 737
 738     /* find all target pins of this connection */
 739     Status = MMixerGetTargetPinsByNodeConnectionIndex(MixerContext, NodeConnections, NodeTypes, FALSE, PinConnectionIndex[0], PinsRef);
 740     if (Status != MM_STATUS_SUCCESS)
 741     {
 742         MixerContext->Close(hDevice);
 743         MixerContext->Free(PinsRef);
 744         MixerContext->Free(NodeTypes);
 745         MixerContext->Free(NodeConnections);
 746         MixerContext->Free(PinConnectionIndex);
 747         return Status;
 748     }
 749
 750     for(Index = 0; Index < PinsRefCount; Index++)
 751     {
 752         DPRINT("PinsRefCount %lu Index %lu Value %lu\n", PinsRefCount, Index, PinsRef[Index]);
 753         if (PinsRef[Index])
 754         {
 755             // found a target pin, now get all references
 756             Status = MMixerGetNodeIndexes(MixerContext, NodeConnections, Index, FALSE, FALSE, &MixerControlsCount, &MixerControls);
 757             if (Status != MM_STATUS_SUCCESS)
 758             {
 759                 DPRINT("MMixerGetNodeIndexes failed with %u\n", Status);
 760                 break;
 761             }
 762
 763             /* sanity check */
 764             ASSERT(MixerControlsCount == 1);
 765
 766             PinsSrcRef = (PULONG)MixerContext->Alloc(PinsRefCount * sizeof(ULONG));
 767             if (!PinsSrcRef)
 768             {
 769                 /* no memory */
 770                 MixerContext->Close(hDevice);
 771                 MixerContext->Free(PinsRef);
 772                 MixerContext->Free(NodeTypes);
 773                 MixerContext->Free(NodeConnections);
 774                 MixerContext->Free(PinConnectionIndex);
 775                 MixerContext->Free(MixerControls);
 776                 return MM_STATUS_NO_MEMORY;
 777             }
 778
 779             // now get all connected source pins
 780             Status = MMixerGetTargetPinsByNodeConnectionIndex(MixerContext, NodeConnections, NodeTypes, TRUE, MixerControls[0], PinsSrcRef);
 781             if (Status != MM_STATUS_SUCCESS)
 782             {
 783                 // failed */
 784                 MixerContext->Close(hDevice);
 785                 MixerContext->Free(PinsRef);
 786                 MixerContext->Free(NodeTypes);
 787                 MixerContext->Free(NodeConnections);
 788                 MixerContext->Free(PinConnectionIndex);
 789                 MixerContext->Free(MixerControls);
 790                 MixerContext->Free(PinsSrcRef);
 791                 return Status;
 792             }
 793
 794             /* add pins from target line */
 795             if (!bInput)
 796             {
 797                 // dont add bridge pin for input mixers
 798                 PinsSrcRef[Index] = TRUE;
 799                 PinsSrcRef[OutConnection->Pin] = TRUE;
 800             }
 801             PinsSrcRef[OutConnection->Pin] = TRUE;
 802
 803             Status = MMixerAddMixerSourceLines(MixerContext, MixerInfo, hDevice, NodeConnections, NodeTypes, PinsRefCount, OutConnection->Pin, Index, PinsSrcRef);
 804
 805             MixerContext->Free(MixerControls);
 806             MixerContext->Free(PinsSrcRef);
 807         }
 808     }
 809
 810     return Status;
 811 }
 812
 813
 814 MIXER_STATUS
 815 MMixerInitializeFilter(
 816     IN PMIXER_CONTEXT MixerContext,
 817     IN PMIXER_LIST MixerList,
 818     IN HANDLE hMixer,
 819     IN LPWSTR DeviceName,
 820     IN PKSMULTIPLE_ITEM NodeTypes,
 821     IN PKSMULTIPLE_ITEM NodeConnections,
 822     IN ULONG PinCount,
 823     IN ULONG NodeIndex,
 824     IN ULONG bInputMixer)
 825 {
 826     LPMIXER_INFO MixerInfo;
 827     MIXER_STATUS Status;
 828     PKSPIN_PHYSICALCONNECTION OutConnection;
 829     ULONG Index;
 830     ULONG * Pins;
 831     ULONG bUsed;
 832     ULONG BytesReturned;
 833     KSP_PIN Pin;
 834     LPWSTR Buffer = NULL;
 835
 836     // allocate a mixer info struct
 837     MixerInfo = (LPMIXER_INFO) MixerContext->Alloc(sizeof(MIXER_INFO));
 838     if (!MixerInfo)
 839     {
 840         // no memory
 841         return MM_STATUS_NO_MEMORY;
 842     }
 843
 844     // intialize mixer caps */
 845     MixerInfo->MixCaps.wMid = MM_MICROSOFT; //FIXME
 846     MixerInfo->MixCaps.wPid = MM_PID_UNMAPPED; //FIXME
 847     MixerInfo->MixCaps.vDriverVersion = 1; //FIXME
 848     MixerInfo->MixCaps.fdwSupport = 0;
 849     MixerInfo->MixCaps.cDestinations = 1;
 850     MixerInfo->hMixer = hMixer;
 851
 852     // initialize line list
 853     InitializeListHead(&MixerInfo->LineList);
 854
 855     /* FIXME find mixer name */
 856
 857     // now allocate an array which will receive the indices of the pin
 858     // which has a ADC / DAC nodetype in its path
 859     Pins = (PULONG)MixerContext->Alloc(PinCount * sizeof(ULONG));
 860
 861     if (!Pins)
 862     {
 863         // no memory
 864         MMixerFreeMixerInfo(MixerContext, MixerInfo);
 865         return MM_STATUS_NO_MEMORY;
 866     }
 867
 868     // now get the target pins of the ADC / DAC node
 869     Status = MMixerGetTargetPins(MixerContext, NodeTypes, NodeConnections, NodeIndex, !bInputMixer, Pins, PinCount);
 870
 871     for(Index = 0; Index < PinCount; Index++)
 872     {
 873         if (Pins[Index])
 874         {
 875             /* retrieve pin name */
 876             Pin.PinId = Index;
 877             Pin.Reserved = 0;
 878             Pin.Property.Flags = KSPROPERTY_TYPE_GET;
 879             Pin.Property.Set = KSPROPSETID_Pin;
 880             Pin.Property.Id = KSPROPERTY_PIN_NAME;
 881
 882             /* try get pin name size */
 883             Status = MixerContext->Control(hMixer, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), NULL, 0, &BytesReturned);
 884
 885             if (Status == MM_STATUS_MORE_ENTRIES)
 886             {
 887                 Buffer = (LPWSTR)MixerContext->Alloc(BytesReturned);
 888                 if (Buffer)
 889                 {
 890                     /* try get pin name */
 891                     Status = MixerContext->Control(hMixer, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)Buffer, BytesReturned, &BytesReturned);
 892                     if (Status != MM_STATUS_SUCCESS)
 893                     {
 894                         MixerContext->Free((PVOID)Buffer);
 895                         Buffer = NULL;
 896                     }
 897                     else
 898                     {
 899                         // found name, done
 900                         break;
 901                     }
 902                 }
 903             }
 904         }
 905     }
 906
 907     Status = MMixerCreateDestinationLine(MixerContext, MixerInfo, bInputMixer, Buffer);
 908
 909     if (Buffer)
 910     {
 911         // free name
 912         MixerContext->Free(Buffer);
 913     }
 914
 915     if (Status != MM_STATUS_SUCCESS)
 916     {
 917         // failed to create destination line
 918         MixerContext->Free(MixerInfo);
 919         MixerContext->Free(Pins);
 920
 921         return Status;
 922     }
 923
 924     RtlZeroMemory(Pins, sizeof(ULONG) * PinCount);
 925     // now get the target pins of the ADC / DAC node
 926     Status = MMixerGetTargetPins(MixerContext, NodeTypes, NodeConnections, NodeIndex, bInputMixer, Pins, PinCount);
 927
 928     if (Status != MM_STATUS_SUCCESS)
 929     {
 930         // failed to locate target pins
 931         MixerContext->Free(Pins);
 932         MMixerFreeMixerInfo(MixerContext, MixerInfo);
 933         DPRINT("MMixerGetTargetPins failed with %u\n", Status);
 934         return Status;
 935     }
 936
 937     // filter hasnt been used
 938     bUsed = FALSE;
 939
 940     // now check all pins and generate new lines for destination lines
 941     for(Index = 0; Index < PinCount; Index++)
 942     {
 943         DPRINT("Index %lu TargetPin %lu\n", Index, Pins[Index]);
 944         // is the current index a target pin
 945         if (Pins[Index])
 946         {
 947             // check if the pin has a physical connection
 948             Status = MMixerGetPhysicalConnection(MixerContext, hMixer, Index, &OutConnection);
 949             if (Status == MM_STATUS_SUCCESS)
 950             {
 951                 // the pin has a physical connection
 952                 Status = MMixerHandlePhysicalConnection(MixerContext, MixerInfo, bInputMixer, OutConnection);
 953                 DPRINT("MMixerHandlePhysicalConnection status %u\n", Status);
 954                 MixerContext->Free(OutConnection);
 955                 bUsed = TRUE;
 956             }
 957             else
 958             {
 959                 // filter exposes the topology on the same filter
 960                 MMixerAddMixerSourceLine(MixerContext, MixerInfo, hMixer, NodeConnections, NodeTypes, Index, FALSE, FALSE);
 961                 bUsed = TRUE;
 962             }
 963         }
 964     }
 965     MixerContext->Free(Pins);
 966
 967     if (bUsed)
 968     {
 969         // store mixer info in list
 970         if (!bInputMixer && MixerList->MixerListCount == 1)
 971         {
 972             //FIXME preferred device should be inserted at front
 973             //windows always inserts output mixer in front
 974             InsertHeadList(&MixerList->MixerList, &MixerInfo->Entry);
 975         }
 976         else
 977         {
 978             InsertTailList(&MixerList->MixerList, &MixerInfo->Entry);
 979         }
 980         MixerList->MixerListCount++;
 981         DPRINT("New MixerCount %lu\n", MixerList->MixerListCount);
 982     }
 983     else
 984     {
 985         // failed to create a mixer topology
 986         MMixerFreeMixerInfo(MixerContext, MixerInfo);
 987     }
 988
 989     // done
 990     return Status;
 991 }
 992
 993 MIXER_STATUS
 994 MMixerSetupFilter(
 995     IN PMIXER_CONTEXT MixerContext,
 996     IN PMIXER_LIST MixerList,
 997     IN HANDLE hMixer,
 998     IN PULONG DeviceCount,
 999     IN LPWSTR DeviceName)
1000 {
1001     PKSMULTIPLE_ITEM NodeTypes, NodeConnections;
1002     MIXER_STATUS Status;
1003     ULONG PinCount;
1004     ULONG NodeIndex;
1005
1006     // get number of pins
1007     PinCount = MMixerGetFilterPinCount(MixerContext, hMixer);
1008     ASSERT(PinCount);
1009     DPRINT("NumOfPins: %lu\n", PinCount);
1010
1011     // get filter node types
1012     Status = MMixerGetFilterTopologyProperty(MixerContext, hMixer, KSPROPERTY_TOPOLOGY_NODES, &NodeTypes);
1013     if (Status != MM_STATUS_SUCCESS)
1014     {
1015         // failed
1016         return Status;
1017     }
1018
1019     // get filter node connections
1020     Status = MMixerGetFilterTopologyProperty(MixerContext, hMixer, KSPROPERTY_TOPOLOGY_CONNECTIONS, &NodeConnections);
1021     if (Status != MM_STATUS_SUCCESS)
1022     {
1023         // failed
1024         MixerContext->Free(NodeTypes);
1025         return Status;
1026     }
1027
1028     // check if the filter has an wave out node
1029     NodeIndex = MMixerGetIndexOfGuid(NodeTypes, &KSNODETYPE_DAC);
1030     if (NodeIndex != MAXULONG)
1031     {
1032         // it has
1033         Status = MMixerInitializeFilter(MixerContext, MixerList, hMixer, DeviceName, NodeTypes, NodeConnections, PinCount, NodeIndex, FALSE);
1034         DPRINT("MMixerInitializeFilter Status %u\n", Status);
1035         // check for success
1036         if (Status == MM_STATUS_SUCCESS)
1037         {
1038             // increment mixer count
1039             (*DeviceCount)++;
1040         }
1041
1042     }
1043
1044     // check if the filter has an wave in node
1045     NodeIndex = MMixerGetIndexOfGuid(NodeTypes, &KSNODETYPE_ADC);
1046     if (NodeIndex != MAXULONG)
1047     {
1048         // it has
1049         Status = MMixerInitializeFilter(MixerContext, MixerList, hMixer, DeviceName, NodeTypes, NodeConnections, PinCount, NodeIndex, TRUE);
1050         DPRINT("MMixerInitializeFilter Status %u\n", Status);
1051         // check for success
1052         if (Status == MM_STATUS_SUCCESS)
1053         {
1054             // increment mixer count
1055             (*DeviceCount)++;
1056         }
1057
1058     }
1059
1060     //free resources
1061     MixerContext->Free((PVOID)NodeTypes);
1062     MixerContext->Free((PVOID)NodeConnections);
1063
1064     // done
1065     return Status;
1066 }