sdk/lib/drivers/sound/mmixer/sup.c

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