ReactOS  0.4.13-dev-563-g0561610
sup.c File Reference
#include "precomp.h"
#include <debug.h>
Include dependency graph for sup.c:

Go to the source code of this file.

Macros

#define YDEBUG
 

Functions

MIXER_STATUS MMixerVerifyContext (IN PMIXER_CONTEXT MixerContext)
 
LPMIXERLINE_EXT MMixerGetMixerLineContainingNodeId (IN LPMIXER_INFO MixerInfo, IN ULONG NodeID)
 
VOID MMixerGetLowestLogicalTopologyPinOffsetFromArray (IN ULONG LogicalPinArrayCount, IN PULONG LogicalPinArray, OUT PULONG PinOffset)
 
VOID MMixerFreeMixerInfo (IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo)
 
LPMIXER_DATA MMixerGetMixerDataByDeviceHandle (IN PMIXER_CONTEXT MixerContext, IN HANDLE hDevice)
 
LPMIXER_INFO MMixerGetMixerInfoByIndex (IN PMIXER_CONTEXT MixerContext, IN ULONG MixerIndex)
 
MIXER_STATUS MMixerGetMixerByName (IN PMIXER_LIST MixerList, IN LPWSTR MixerName, OUT LPMIXER_INFO *OutMixerInfo)
 
LPMIXERLINE_EXT MMixerGetSourceMixerLineByLineId (LPMIXER_INFO MixerInfo, DWORD dwLineID)
 
LPGUID MMixerGetNodeType (IN PKSMULTIPLE_ITEM MultipleItem, IN ULONG Index)
 
LPMIXERLINE_EXT MMixerGetSourceMixerLineByComponentType (LPMIXER_INFO MixerInfo, DWORD dwComponentType)
 
MIXER_STATUS MMixerGetMixerControlById (LPMIXER_INFO MixerInfo, DWORD dwControlID, LPMIXERLINE_EXT *OutMixerLine, LPMIXERCONTROL_EXT *OutMixerControl, PULONG NodeId)
 
ULONG MMixerGetVolumeControlIndex (LPMIXERVOLUME_DATA VolumeData, LONG Value)
 
VOID MMixerNotifyControlChange (IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN ULONG NotificationType, IN ULONG Value)
 
MIXER_STATUS MMixerSetGetMuteControlDetails (IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN LPMIXERCONTROL_EXT MixerControl, IN ULONG dwLineID, IN LPMIXERCONTROLDETAILS MixerControlDetails, IN ULONG bSet)
 
MIXER_STATUS MMixerSetGetMuxControlDetails (IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN ULONG NodeId, IN ULONG bSet, IN ULONG Flags, IN LPMIXERCONTROL_EXT MixerControl, IN LPMIXERCONTROLDETAILS MixerControlDetails, IN LPMIXERLINE_EXT MixerLine)
 
MIXER_STATUS MMixerSetGetVolumeControlDetails (IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN ULONG NodeId, IN ULONG bSet, LPMIXERCONTROL_EXT MixerControl, IN LPMIXERCONTROLDETAILS MixerControlDetails, LPMIXERLINE_EXT MixerLine)
 
LPMIXER_DATA MMixerGetDataByDeviceId (IN PMIXER_LIST MixerList, IN ULONG DeviceId)
 
LPMIXER_DATA MMixerGetDataByDeviceName (IN PMIXER_LIST MixerList, IN LPWSTR DeviceName)
 
MIXER_STATUS MMixerCreateMixerData (IN PMIXER_CONTEXT MixerContext, IN PMIXER_LIST MixerList, IN ULONG DeviceId, IN LPWSTR DeviceName, IN HANDLE hDevice, IN HANDLE hKey)
 
MIXER_STATUS MMixerGetDeviceNameWithComponentId (IN PMIXER_CONTEXT MixerContext, IN HANDLE hMixer, OUT LPWSTR OutDeviceName)
 
MIXER_STATUS MMixerGetDeviceName (IN PMIXER_CONTEXT MixerContext, OUT LPWSTR DeviceName, IN HANDLE hKey)
 
VOID MMixerInitializePinConnect (IN OUT PKSPIN_CONNECT PinConnect, IN ULONG PinId)
 

Variables

const GUID KSNODETYPE_SUM = {0xDA441A60L, 0xC556, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSNODETYPE_DAC = {0x507AE360L, 0xC554, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSNODETYPE_ADC = {0x4D837FE0L, 0xC555, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSNODETYPE_AGC = {0xE88C9BA0L, 0xC557, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSNODETYPE_LOUDNESS = {0x41887440L, 0xC558, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSNODETYPE_MUTE = {0x02B223C0L, 0xC557, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSNODETYPE_TONE = {0x7607E580L, 0xC557, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSNODETYPE_VOLUME = {0x3A5ACC00L, 0xC557, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSNODETYPE_PEAKMETER = {0xa085651e, 0x5f0d, 0x4b36, {0xa8, 0x69, 0xd1, 0x95, 0xd6, 0xab, 0x4b, 0x9e}}
 
const GUID KSNODETYPE_MUX = {0x2CEAF780, 0xC556, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSNODETYPE_STEREO_WIDE = {0xA9E69800L, 0xC558, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSNODETYPE_CHORUS = {0x20173F20L, 0xC559, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSNODETYPE_REVERB = {0xEF0328E0L, 0xC558, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSNODETYPE_SUPERMIX = {0xE573ADC0L, 0xC555, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}
 
const GUID KSPROPSETID_Audio = {0x45FFAAA0L, 0x6E1B, 0x11D0, {0xBC, 0xF2, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}}
 
const GUID KSPROPSETID_Pin = {0x8C134960L, 0x51AD, 0x11CF, {0x87, 0x8A, 0x94, 0xF8, 0x01, 0xC1, 0x00, 0x00}}
 
const GUID KSPROPSETID_General = {0x1464EDA5L, 0x6A8F, 0x11D1, {0x9A, 0xA7, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}}
 
const GUID KSPROPSETID_Topology = {0x720D4AC0L, 0x7533, 0x11D0, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}}
 
const GUID KSEVENTSETID_AudioControlChange = {0xE85E9698L, 0xFA2F, 0x11D1, {0x95, 0xBD, 0x00, 0xC0, 0x4F, 0xB9, 0x25, 0xD3}}
 
const GUID KSDATAFORMAT_TYPE_MUSIC = {0xE725D360L, 0x62CC, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}}
 
const GUID KSDATAFORMAT_SUBTYPE_MIDI = {0x1D262760L, 0xE957, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}}
 
const GUID KSDATAFORMAT_SPECIFIER_NONE = {0x0F6417D6L, 0xC318, 0x11D0, {0xA4, 0x3F, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}}
 

Macro Definition Documentation

◆ YDEBUG

#define YDEBUG

Definition at line 11 of file sup.c.

Function Documentation

◆ MMixerCreateMixerData()

MIXER_STATUS MMixerCreateMixerData ( IN PMIXER_CONTEXT  MixerContext,
IN PMIXER_LIST  MixerList,
IN ULONG  DeviceId,
IN LPWSTR  DeviceName,
IN HANDLE  hDevice,
IN HANDLE  hKey 
)

Definition at line 779 of file sup.c.

786 {
787  LPMIXER_DATA MixerData;
788 
789  MixerData = (LPMIXER_DATA)MixerContext->Alloc(sizeof(MIXER_DATA));
790  if (!MixerData)
791  return MM_STATUS_NO_MEMORY;
792 
793  MixerData->DeviceId = DeviceId;
794  MixerData->DeviceName = DeviceName;
795  MixerData->hDevice = hDevice;
796  MixerData->hDeviceInterfaceKey = hKey;
797  MixerData->Topology = NULL;
798 
799  InsertTailList(&MixerList->MixerData, &MixerData->Entry);
800  MixerList->MixerDataCount++;
801  return MM_STATUS_SUCCESS;
802 }
LPWSTR DeviceName
Definition: precomp.h:117
WCHAR DeviceName[]
Definition: adapter.cpp:21
#define InsertTailList(ListHead, Entry)
struct MIXER_DATA * LPMIXER_DATA
MIXER_CONTEXT MixerContext
Definition: mmixer.c:46
smooth NULL
Definition: ftsmooth.c:416
HANDLE hDeviceInterfaceKey
Definition: precomp.h:116
HANDLE hDevice
Definition: precomp.h:115
ULONG DeviceId
Definition: precomp.h:114
PTOPOLOGY Topology
Definition: precomp.h:118
PMIXER_ALLOC Alloc
Definition: mmixer.h:94
LIST_ENTRY Entry
Definition: precomp.h:113

Referenced by MMixerInitialize().

◆ MMixerFreeMixerInfo()

VOID MMixerFreeMixerInfo ( IN PMIXER_CONTEXT  MixerContext,
IN LPMIXER_INFO  MixerInfo 
)

Definition at line 116 of file sup.c.

119 {
120  /* UNIMPLEMENTED;
121  * FIXME
122  * free all lines
123  */
124 
125  MixerContext->Free((PVOID)MixerInfo);
126 }
MIXER_CONTEXT MixerContext
Definition: mmixer.c:46
PMIXER_FREE Free
Definition: mmixer.h:96

◆ MMixerGetDataByDeviceId()

LPMIXER_DATA MMixerGetDataByDeviceId ( IN PMIXER_LIST  MixerList,
IN ULONG  DeviceId 
)

Definition at line 736 of file sup.c.

739 {
741  LPMIXER_DATA MixerData;
742 
743  Entry = MixerList->MixerData.Flink;
744  while(Entry != &MixerList->MixerData)
745  {
747  if (MixerData->DeviceId == DeviceId)
748  {
749  return MixerData;
750  }
751  Entry = Entry->Flink;
752  }
753  return NULL;
754 }
struct _Entry Entry
Definition: kefuncs.h:640
struct MIXER_DATA * LPMIXER_DATA
smooth NULL
Definition: ftsmooth.c:416
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
ULONG DeviceId
Definition: precomp.h:114
Definition: typedefs.h:117
base of all file and directory entries
Definition: entries.h:82

Referenced by MMixerGetMidiDevicePath(), MMixerGetWaveDevicePath(), MMixerOpenMidiPin(), and MMixerOpenWavePin().

◆ MMixerGetDataByDeviceName()

LPMIXER_DATA MMixerGetDataByDeviceName ( IN PMIXER_LIST  MixerList,
IN LPWSTR  DeviceName 
)

Definition at line 757 of file sup.c.

760 {
762  LPMIXER_DATA MixerData;
763 
764  Entry = MixerList->MixerData.Flink;
765  while(Entry != &MixerList->MixerData)
766  {
768  if (wcsicmp(&DeviceName[2], &MixerData->DeviceName[2]) == 0)
769  {
770  /* found entry */
771  return MixerData;
772  }
773  Entry = Entry->Flink;
774  }
775  return NULL;
776 }
struct _Entry Entry
Definition: kefuncs.h:640
LPWSTR DeviceName
Definition: precomp.h:117
WCHAR DeviceName[]
Definition: adapter.cpp:21
struct MIXER_DATA * LPMIXER_DATA
smooth NULL
Definition: ftsmooth.c:416
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
Definition: typedefs.h:117
#define wcsicmp
Definition: string.h:1152
base of all file and directory entries
Definition: entries.h:82

Referenced by MMixerHandlePhysicalConnection().

◆ MMixerGetDeviceName()

MIXER_STATUS MMixerGetDeviceName ( IN PMIXER_CONTEXT  MixerContext,
OUT LPWSTR  DeviceName,
IN HANDLE  hKey 
)

Definition at line 852 of file sup.c.

856 {
857  LPWSTR Name;
858  HANDLE hTemp;
859  ULONG Length;
860  ULONG Type;
862 
863  Status = MixerContext->QueryKeyValue(hKey, L"FriendlyName", (PVOID*)&Name, &Length, &Type);
864  if (Status == MM_STATUS_SUCCESS)
865  {
866  /* copy device name */
868 
869  /* make sure its null terminated */
870  DeviceName[MAXPNAMELEN-1] = L'\0';
871 
872  /* free device name */
874 
875  /* done */
876  return Status;
877  }
878 
879  Status = MixerContext->OpenKey(hKey, L"Device Parameters", KEY_READ, &hTemp);
880  if (Status != MM_STATUS_SUCCESS)
881  return Status;
882 
883  Status = MixerContext->QueryKeyValue(hTemp, L"FriendlyName", (PVOID*)&Name, &Length, &Type);
884  if (Status == MM_STATUS_SUCCESS)
885  {
886  /* copy device name */
888 
889  /* make sure its null terminated */
890  DeviceName[MAXPNAMELEN-1] = L'\0';
891 
892  /* free device name */
894  }
895 
896  MixerContext->CloseKey(hTemp);
897  return Status;
898 }
Type
Definition: Type.h:6
#define KEY_READ
Definition: nt_native.h:1023
PMIXER_OPEN_KEY OpenKey
Definition: mmixer.h:100
WCHAR DeviceName[]
Definition: adapter.cpp:21
MIXER_CONTEXT MixerContext
Definition: mmixer.c:46
struct NameRec_ * Name
Definition: cdprocs.h:464
PMIXER_FREE Free
Definition: mmixer.h:96
PMIXER_QUERY_KEY_VALUE QueryKeyValue
Definition: mmixer.h:101
__wchar_t WCHAR
Definition: xmlstorage.h:180
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
static const WCHAR L[]
Definition: oid.c:1250
Status
Definition: gdiplustypes.h:24
MIXER_STATUS
Definition: mmixer.h:3
#define min(a, b)
Definition: monoChain.cc:55
PMIXER_CLOSEKEY CloseKey
Definition: mmixer.h:102
#define MAXPNAMELEN
Definition: mmsystem.h:24
unsigned int ULONG
Definition: retypes.h:1
WCHAR * LPWSTR
Definition: xmlstorage.h:184
PMIXER_COPY Copy
Definition: mmixer.h:99
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)

Referenced by MMixerInitializeFilter(), and MMixerInitializeMidiForFilter().

◆ MMixerGetDeviceNameWithComponentId()

MIXER_STATUS MMixerGetDeviceNameWithComponentId ( IN PMIXER_CONTEXT  MixerContext,
IN HANDLE  hMixer,
OUT LPWSTR  OutDeviceName 
)

Definition at line 805 of file sup.c.

809 {
813  ULONG Length;
815  ULONG ResultLength, KeyType;
816  HANDLE hMediaKey, hGuidKey;
818 
819  /* prepare property */
823 
824  /* try get component id */
826 
827  if (Status == MM_STATUS_SUCCESS)
828  {
829  Status = MixerContext->OpenKey(NULL, L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\MediaCategories", KEY_READ, &hMediaKey);
830  if (Status == MM_STATUS_SUCCESS)
831  {
833  Status = MixerContext->OpenKey(hMediaKey, GuidString.Buffer, KEY_READ, &hGuidKey);
835  if (Status == MM_STATUS_SUCCESS)
836  {
837  Status = MixerContext->QueryKeyValue(hGuidKey, L"Name", (PVOID*)&DeviceName, &ResultLength, &KeyType);
838  if (Status == MM_STATUS_SUCCESS)
839  {
840  MixerContext->Copy(OutDeviceName, DeviceName, min(ResultLength, (MAXPNAMELEN-1)*2));
841  }
842 
843  MixerContext->CloseKey(hGuidKey);
844  }
845  MixerContext->CloseKey(hMediaKey);
846  }
847  }
848  return Status;
849 }
IN CINT OUT PVOID IN ULONG OUT PULONG ResultLength
Definition: conport.c:47
static PWSTR GuidString
Definition: apphelp.c:91
#define IOCTL_KS_PROPERTY
Definition: ks.h:150
#define KEY_READ
Definition: nt_native.h:1023
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 ACPI_STATUS const char UINT32 ACPI_STATUS const char UINT32 const char const char UINT32 ComponentId
Definition: acpixf.h:1252
PMIXER_OPEN_KEY OpenKey
Definition: mmixer.h:100
WCHAR DeviceName[]
Definition: adapter.cpp:21
#define KSPROPERTY_TYPE_GET
Definition: dmksctrl.h:42
MIXER_CONTEXT MixerContext
Definition: mmixer.c:46
PMIXER_DEVICE_CONTROL Control
Definition: mmixer.h:95
HMIXER hMixer
Definition: test.c:10
smooth NULL
Definition: ftsmooth.c:416
PMIXER_QUERY_KEY_VALUE QueryKeyValue
Definition: mmixer.h:101
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
static const WCHAR L[]
Definition: oid.c:1250
NTSYSAPI NTSTATUS WINAPI RtlStringFromGUID(REFGUID, PUNICODE_STRING)
Status
Definition: gdiplustypes.h:24
_In_ DWORD Property
Definition: setupapi.h:1545
MIXER_STATUS
Definition: mmixer.h:3
#define min(a, b)
Definition: monoChain.cc:55
const GUID KSPROPSETID_General
Definition: sup.c:31
PMIXER_CLOSEKEY CloseKey
Definition: mmixer.h:102
#define MAXPNAMELEN
Definition: mmsystem.h:24
unsigned int ULONG
Definition: retypes.h:1
WCHAR * LPWSTR
Definition: xmlstorage.h:184
PMIXER_COPY Copy
Definition: mmixer.h:99

Referenced by MMixerInitializeFilter().

◆ MMixerGetLowestLogicalTopologyPinOffsetFromArray()

VOID MMixerGetLowestLogicalTopologyPinOffsetFromArray ( IN ULONG  LogicalPinArrayCount,
IN PULONG  LogicalPinArray,
OUT PULONG  PinOffset 
)

Definition at line 91 of file sup.c.

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 }
static const UCHAR Index[8]
Definition: usbohci.c:18
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define MAXULONG
Definition: typedefs.h:250
unsigned int ULONG
Definition: retypes.h:1

Referenced by MMixerSetGetMuxControlDetails().

◆ MMixerGetMixerByName()

MIXER_STATUS MMixerGetMixerByName ( IN PMIXER_LIST  MixerList,
IN LPWSTR  MixerName,
OUT LPMIXER_INFO OutMixerInfo 
)

Definition at line 194 of file sup.c.

198 {
199  LPMIXER_INFO MixerInfo;
201 
202  Entry = MixerList->MixerList.Flink;
203  while(Entry != &MixerList->MixerList)
204  {
206 
207  DPRINT1("MixerName %S MixerName %S\n", MixerInfo->MixCaps.szPname, MixerName);
208  if (wcsicmp(MixerInfo->MixCaps.szPname, MixerName) == 0)
209  {
210  *OutMixerInfo = MixerInfo;
211  return MM_STATUS_SUCCESS;
212  }
213  /* move to next mixer entry */
214  Entry = Entry->Flink;
215  }
216 
217  return MM_STATUS_UNSUCCESSFUL;
218 }
struct _Entry Entry
Definition: kefuncs.h:640
MIXERCAPSW MixCaps
Definition: precomp.h:70
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
Definition: typedefs.h:117
#define wcsicmp
Definition: string.h:1152
#define DPRINT1
Definition: precomp.h:8
struct MIXER_INFO * LPMIXER_INFO
WCHAR szPname[MAXPNAMELEN]
Definition: mmsystem.h:1226
base of all file and directory entries
Definition: entries.h:82

◆ MMixerGetMixerControlById()

MIXER_STATUS MMixerGetMixerControlById ( LPMIXER_INFO  MixerInfo,
DWORD  dwControlID,
LPMIXERLINE_EXT OutMixerLine,
LPMIXERCONTROL_EXT OutMixerControl,
PULONG  NodeId 
)

Definition at line 281 of file sup.c.

287 {
288  PLIST_ENTRY Entry, ControlEntry;
289  LPMIXERLINE_EXT MixerLineSrc;
290  LPMIXERCONTROL_EXT MixerControl;
291 
292  /* get first entry */
293  Entry = MixerInfo->LineList.Flink;
294 
295  while(Entry != &MixerInfo->LineList)
296  {
298 
299  ControlEntry = MixerLineSrc->ControlsList.Flink;
300  while(ControlEntry != &MixerLineSrc->ControlsList)
301  {
302  MixerControl = (LPMIXERCONTROL_EXT)CONTAINING_RECORD(ControlEntry, MIXERCONTROL_EXT, Entry);
303  if (MixerControl->Control.dwControlID == dwControlID)
304  {
305  if (OutMixerLine)
306  *OutMixerLine = MixerLineSrc;
307  if (OutMixerControl)
308  *OutMixerControl = MixerControl;
309  if (NodeId)
310  *NodeId = MixerControl->NodeID;
311  return MM_STATUS_SUCCESS;
312  }
313  ControlEntry = ControlEntry->Flink;
314  }
315  Entry = Entry->Flink;
316  }
317 
318  return MM_STATUS_UNSUCCESSFUL;
319 }
MIXERCONTROLW Control
Definition: precomp.h:79
struct _Entry Entry
Definition: kefuncs.h:640
LIST_ENTRY LineList
Definition: precomp.h:71
struct MIXERCONTROL_EXT * LPMIXERCONTROL_EXT
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
ULONG NodeID
Definition: precomp.h:80
Definition: typedefs.h:117
LIST_ENTRY ControlsList
Definition: precomp.h:90
base of all file and directory entries
Definition: entries.h:82
struct MIXERLINE_EXT * LPMIXERLINE_EXT

Referenced by MMixerGetControlDetails(), MMixerGetLineControls(), and MMixerSetControlDetails().

◆ MMixerGetMixerDataByDeviceHandle()

LPMIXER_DATA MMixerGetMixerDataByDeviceHandle ( IN PMIXER_CONTEXT  MixerContext,
IN HANDLE  hDevice 
)

Definition at line 130 of file sup.c.

133 {
134  LPMIXER_DATA MixerData;
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  {
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 }
struct _Entry Entry
Definition: kefuncs.h:640
LIST_ENTRY MixerData
Definition: precomp.h:153
struct MIXER_DATA * LPMIXER_DATA
MIXER_CONTEXT MixerContext
Definition: mmixer.c:46
smooth NULL
Definition: ftsmooth.c:416
HANDLE hDevice
Definition: precomp.h:115
ULONG MixerDataCount
Definition: precomp.h:152
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
if(!(yy_init))
Definition: macro.lex.yy.c:714
Definition: typedefs.h:117
PVOID MixerContext
Definition: mmixer.h:92
struct MIXER_LIST * PMIXER_LIST
base of all file and directory entries
Definition: entries.h:82

Referenced by MMixerSetGetMuxControlDetails().

◆ MMixerGetMixerInfoByIndex()

LPMIXER_INFO MMixerGetMixerInfoByIndex ( IN PMIXER_CONTEXT  MixerContext,
IN ULONG  MixerIndex 
)

Definition at line 161 of file sup.c.

164 {
165  LPMIXER_INFO MixerInfo;
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  {
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 }
struct _Entry Entry
Definition: kefuncs.h:640
LIST_ENTRY MixerList
Definition: precomp.h:150
MIXER_CONTEXT MixerContext
Definition: mmixer.c:46
smooth NULL
Definition: ftsmooth.c:416
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
if(!(yy_init))
Definition: macro.lex.yy.c:714
static const UCHAR Index[8]
Definition: usbohci.c:18
Definition: typedefs.h:117
PVOID MixerContext
Definition: mmixer.h:92
struct MIXER_LIST * PMIXER_LIST
struct MIXER_INFO * LPMIXER_INFO
unsigned int ULONG
Definition: retypes.h:1
base of all file and directory entries
Definition: entries.h:82
ULONG MixerListCount
Definition: precomp.h:149

Referenced by MMixerClose(), MMixerGetCapabilities(), MMixerGetControlDetails(), MMixerGetLineControls(), MMixerGetLineInfo(), MMixerOpen(), MMixerPrintMixers(), and MMixerSetControlDetails().

◆ MMixerGetMixerLineContainingNodeId()

LPMIXERLINE_EXT MMixerGetMixerLineContainingNodeId ( IN LPMIXER_INFO  MixerInfo,
IN ULONG  NodeID 
)

Definition at line 59 of file sup.c.

62 {
63  PLIST_ENTRY Entry, ControlEntry;
64  LPMIXERLINE_EXT MixerLineSrc;
65  LPMIXERCONTROL_EXT MixerControl;
66 
67  /* get first entry */
68  Entry = MixerInfo->LineList.Flink;
69 
70  while(Entry != &MixerInfo->LineList)
71  {
73 
74  ControlEntry = MixerLineSrc->ControlsList.Flink;
75  while(ControlEntry != &MixerLineSrc->ControlsList)
76  {
77  MixerControl = (LPMIXERCONTROL_EXT)CONTAINING_RECORD(ControlEntry, MIXERCONTROL_EXT, Entry);
78  if (MixerControl->NodeID == NodeID)
79  {
80  return MixerLineSrc;
81  }
82  ControlEntry = ControlEntry->Flink;
83  }
84  Entry = Entry->Flink;
85  }
86 
87  return NULL;
88 }
struct _Entry Entry
Definition: kefuncs.h:640
smooth NULL
Definition: ftsmooth.c:416
struct MIXERCONTROL_EXT * LPMIXERCONTROL_EXT
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
ULONG NodeID
Definition: precomp.h:80
Definition: typedefs.h:117
LIST_ENTRY ControlsList
Definition: precomp.h:90
base of all file and directory entries
Definition: entries.h:82
struct MIXERLINE_EXT * LPMIXERLINE_EXT

Referenced by MMixerSetGetMuxControlDetails().

◆ MMixerGetNodeType()

LPGUID MMixerGetNodeType ( IN PKSMULTIPLE_ITEM  MultipleItem,
IN ULONG  Index 
)

Definition at line 245 of file sup.c.

248 {
250 
251  ASSERT(Index < MultipleItem->Count);
252 
253  NodeType = (LPGUID)(MultipleItem + 1);
254  return &NodeType[Index];
255 }
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
NodeType
Definition: Node.h:5
static const UCHAR Index[8]
Definition: usbohci.c:18
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
GUID * LPGUID
Definition: guiddef.h:76

◆ MMixerGetSourceMixerLineByComponentType()

LPMIXERLINE_EXT MMixerGetSourceMixerLineByComponentType ( LPMIXER_INFO  MixerInfo,
DWORD  dwComponentType 
)

Definition at line 258 of file sup.c.

261 {
263  LPMIXERLINE_EXT MixerLineSrc;
264 
265  /* get first entry */
266  Entry = MixerInfo->LineList.Flink;
267 
268  while(Entry != &MixerInfo->LineList)
269  {
271  if (MixerLineSrc->Line.dwComponentType == dwComponentType)
272  return MixerLineSrc;
273 
274  Entry = Entry->Flink;
275  }
276 
277  return NULL;
278 }
MIXERLINEW Line
Definition: precomp.h:89
struct _Entry Entry
Definition: kefuncs.h:640
LIST_ENTRY LineList
Definition: precomp.h:71
DWORD dwComponentType
Definition: mmsystem.h:1261
smooth NULL
Definition: ftsmooth.c:416
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
Definition: typedefs.h:117
base of all file and directory entries
Definition: entries.h:82
struct MIXERLINE_EXT * LPMIXERLINE_EXT

Referenced by MMixerGetLineInfo().

◆ MMixerGetSourceMixerLineByLineId()

LPMIXERLINE_EXT MMixerGetSourceMixerLineByLineId ( LPMIXER_INFO  MixerInfo,
DWORD  dwLineID 
)

Definition at line 221 of file sup.c.

224 {
226  LPMIXERLINE_EXT MixerLineSrc;
227 
228  /* get first entry */
229  Entry = MixerInfo->LineList.Flink;
230 
231  while(Entry != &MixerInfo->LineList)
232  {
234  DPRINT("dwLineID %x dwLineID %x MixerLineSrc %p\n", MixerLineSrc->Line.dwLineID, dwLineID, MixerLineSrc);
235  if (MixerLineSrc->Line.dwLineID == dwLineID)
236  return MixerLineSrc;
237 
238  Entry = Entry->Flink;
239  }
240 
241  return NULL;
242 }
MIXERLINEW Line
Definition: precomp.h:89
struct _Entry Entry
Definition: kefuncs.h:640
LIST_ENTRY LineList
Definition: precomp.h:71
DWORD dwLineID
Definition: mmsystem.h:1258
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
Definition: typedefs.h:117
base of all file and directory entries
Definition: entries.h:82
struct MIXERLINE_EXT * LPMIXERLINE_EXT

Referenced by MMixerAddMixerControlsToDestinationLine(), MMixerAddMixerSourceLines(), MMixerBuildMixerSourceLine(), MMixerGetLineControls(), MMixerGetLineInfo(), MMixerHandleAlternativeMixers(), and MMixerPrintMixers().

◆ MMixerGetVolumeControlIndex()

ULONG MMixerGetVolumeControlIndex ( LPMIXERVOLUME_DATA  VolumeData,
LONG  Value 
)

Definition at line 322 of file sup.c.

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 }
_In_opt_ ULONG _Out_ PULONG Value
Definition: rtlfuncs.h:2327
ULONG ValuesCount
Definition: precomp.h:107
static const UCHAR Index[8]
Definition: usbohci.c:18
unsigned int ULONG
Definition: retypes.h:1
ULONG InputSteppingDelta
Definition: precomp.h:106

Referenced by MMixerSetGetVolumeControlDetails().

◆ MMixerInitializePinConnect()

VOID MMixerInitializePinConnect ( IN OUT PKSPIN_CONNECT  PinConnect,
IN ULONG  PinId 
)

Definition at line 901 of file sup.c.

904 {
905  PinConnect->Interface.Set = KSINTERFACESETID_Standard;
906  PinConnect->Interface.Id = KSINTERFACE_STANDARD_STREAMING;
907  PinConnect->Interface.Flags = 0;
908  PinConnect->Medium.Set = KSMEDIUMSETID_Standard;
909  PinConnect->Medium.Id = KSMEDIUM_TYPE_ANYINSTANCE;
910  PinConnect->Medium.Flags = 0;
911  PinConnect->PinToHandle = NULL;
912  PinConnect->PinId = PinId;
913  PinConnect->Priority.PriorityClass = KSPRIORITY_NORMAL;
914  PinConnect->Priority.PrioritySubClass = 1;
915 }
#define KSPRIORITY_NORMAL
Definition: ks.h:1416
#define KSINTERFACESETID_Standard
Definition: ks.h:310
#define KSMEDIUMSETID_Standard
Definition: ks.h:336
smooth NULL
Definition: ftsmooth.c:416
#define KSMEDIUM_TYPE_ANYINSTANCE
Definition: ks.h:331

Referenced by MMixerOpenMidiPin(), and MMixerOpenWavePin().

◆ MMixerNotifyControlChange()

VOID MMixerNotifyControlChange ( IN PMIXER_CONTEXT  MixerContext,
IN LPMIXER_INFO  MixerInfo,
IN ULONG  NotificationType,
IN ULONG  Value 
)

Definition at line 339 of file sup.c.

344 {
347 
348  /* enumerate list and perform notification */
349  Entry = MixerInfo->EventList.Flink;
350  while(Entry != &MixerInfo->EventList)
351  {
352  /* get notification entry offset */
354 
355  if (NotificationEntry->MixerEventRoutine)
356  {
357  /* now perform the callback */
358  NotificationEntry->MixerEventRoutine(NotificationEntry->MixerEventContext, (HANDLE)MixerInfo, NotificationType, Value);
359  }
360 
361  /* move to next notification entry */
362  Entry = Entry->Flink;
363  }
364 }
_In_opt_ ULONG _Out_ PULONG Value
Definition: rtlfuncs.h:2327
struct _Entry Entry
Definition: kefuncs.h:640
_In_ ULONG _In_opt_ PVOID _In_ PDRIVER_OBJECT _In_ PDRIVER_NOTIFICATION_CALLBACK_ROUTINE _Inout_opt_ __drv_aliasesMem PVOID _Outptr_result_nullonfailure_ _At_ * NotificationEntry(return==0, __drv_allocatesMem(Mem))) PVOID *NotificationEntry
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
Definition: precomp.h:168
struct EVENT_NOTIFICATION_ENTRY * PEVENT_NOTIFICATION_ENTRY
Definition: typedefs.h:117
base of all file and directory entries
Definition: entries.h:82

Referenced by MMixerSetGetMuteControlDetails(), MMixerSetGetMuxControlDetails(), and MMixerSetGetVolumeControlDetails().

◆ MMixerSetGetMuteControlDetails()

MIXER_STATUS MMixerSetGetMuteControlDetails ( IN PMIXER_CONTEXT  MixerContext,
IN LPMIXER_INFO  MixerInfo,
IN LPMIXERCONTROL_EXT  MixerControl,
IN ULONG  dwLineID,
IN LPMIXERCONTROLDETAILS  MixerControlDetails,
IN ULONG  bSet 
)

Definition at line 367 of file sup.c.

374 {
376  LONG Value;
378 
379  if (MixerControlDetails->cbDetails != sizeof(MIXERCONTROLDETAILS_BOOLEAN))
381 
382  /* get input */
383  Input = (LPMIXERCONTROLDETAILS_BOOLEAN)MixerControlDetails->paDetails;
384 
385  /* FIXME SEH */
386  if (bSet)
387  Value = Input->fValue;
388 
389  /* set control details */
390  Status = MMixerSetGetControlDetails(MixerContext, MixerControl->hDevice, MixerControl->NodeID, bSet, KSPROPERTY_AUDIO_MUTE, 0, &Value);
391 
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 */
405  }
406 
407  return Status;
408 }
_In_opt_ ULONG _Out_ PULONG Value
Definition: rtlfuncs.h:2327
VOID MMixerNotifyControlChange(IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN ULONG NotificationType, IN ULONG Value)
Definition: sup.c:339
struct tMIXERCONTROLDETAILS_BOOLEAN * LPMIXERCONTROLDETAILS_BOOLEAN
Definition: arc.h:84
MIXER_CONTEXT MixerContext
Definition: mmixer.c:46
long LONG
Definition: pedump.c:60
if(!(yy_init))
Definition: macro.lex.yy.c:714
MIXER_STATUS MMixerSetGetControlDetails(IN PMIXER_CONTEXT MixerContext, IN HANDLE hMixer, IN ULONG NodeId, IN ULONG bSet, IN ULONG PropertyId, IN ULONG Channel, IN PLONG InputValue)
Definition: filter.c:219
Status
Definition: gdiplustypes.h:24
MIXER_STATUS
Definition: mmixer.h:3
#define MM_MIXM_LINE_CHANGE
Definition: mmsystem.h:82

Referenced by MMixerGetControlDetails(), and MMixerSetControlDetails().

◆ MMixerSetGetMuxControlDetails()

MIXER_STATUS MMixerSetGetMuxControlDetails ( IN PMIXER_CONTEXT  MixerContext,
IN LPMIXER_INFO  MixerInfo,
IN ULONG  NodeId,
IN ULONG  bSet,
IN ULONG  Flags,
IN LPMIXERCONTROL_EXT  MixerControl,
IN LPMIXERCONTROLDETAILS  MixerControlDetails,
IN LPMIXERLINE_EXT  MixerLine 
)

Definition at line 411 of file sup.c.

420 {
422  PULONG LogicalNodes, ConnectedNodes;
423  ULONG LogicalNodesCount, ConnectedNodesCount, Index, CurLogicalPinOffset, BytesReturned, OldLogicalPinOffset;
424  LPMIXER_DATA MixerData;
427  LPMIXERLINE_EXT SourceLine;
429 
430  DPRINT("MixerControlDetails %p\n", MixerControlDetails);
431  DPRINT("bSet %lx\n", bSet);
432  DPRINT("Flags %lx\n", Flags);
433  DPRINT("NodeId %lu\n", MixerControl->NodeID);
434  DPRINT("MixerControlDetails dwControlID %lu\n", MixerControlDetails->dwControlID);
435  DPRINT("MixerControlDetails cChannels %lu\n", MixerControlDetails->cChannels);
436  DPRINT("MixerControlDetails cMultipleItems %lu\n", MixerControlDetails->cMultipleItems);
437  DPRINT("MixerControlDetails cbDetails %lu\n", MixerControlDetails->cbDetails);
438  DPRINT("MixerControlDetails paDetails %p\n", MixerControlDetails->paDetails);
439 
440  if (MixerControl->Control.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
441  {
442  /* control acts uniform */
443  if (MixerControlDetails->cChannels != 1)
444  {
445  /* expected 1 channel */
446  DPRINT1("Expected 1 channel but got %lu\n", MixerControlDetails->cChannels);
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  {
461  {
462  /* tell me when this is hit */
463  ASSERT(FALSE);
464  }
466  {
467  /* sanity check */
468  ASSERT(bSet == TRUE);
469  ASSERT(MixerControlDetails->cbDetails == sizeof(MIXERCONTROLDETAILS_BOOLEAN));
470 
471  Values = (LPMIXERCONTROLDETAILS_BOOLEAN)MixerControlDetails->paDetails;
472  CurLogicalPinOffset = MAXULONG;
473  for(Index = 0; Index < MixerControlDetails->cMultipleItems; Index++)
474  {
475  if (Values[Index].fValue)
476  {
477  /* mux can only activate one line at a time */
478  ASSERT(CurLogicalPinOffset == MAXULONG);
479  CurLogicalPinOffset = Index;
480  }
481  }
482 
483  /* setup request */
484  Request.NodeId = NodeId;
485  Request.Reserved = 0;
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 */
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  {
524  {
525  /* setup request */
526  Request.NodeId = NodeId;
527  Request.Reserved = 0;
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  }
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 
665 }
VOID MMixerNotifyControlChange(IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN ULONG NotificationType, IN ULONG Value)
Definition: sup.c:339
LPMIXER_DATA MMixerGetMixerDataByDeviceHandle(IN PMIXER_CONTEXT MixerContext, IN HANDLE hDevice)
Definition: sup.c:130
LPMIXERLINE_EXT MMixerGetMixerLineContainingNodeId(IN LPMIXER_INFO MixerInfo, IN ULONG NodeID)
Definition: sup.c:59
#define IOCTL_KS_PROPERTY
Definition: ks.h:150
#define MIXER_GETCONTROLDETAILSF_VALUE
Definition: mmsystem.h:412
#define TRUE
Definition: types.h:120
MIXERLINEW Line
Definition: precomp.h:89
#define MIXER_SETCONTROLDETAILSF_CUSTOM
Definition: mmsystem.h:416
struct tMIXERCONTROLDETAILS_BOOLEAN * LPMIXERCONTROLDETAILS_BOOLEAN
#define MIXER_GETCONTROLDETAILSF_LISTTEXT
Definition: mmsystem.h:413
DWORD dwLineID
Definition: mmsystem.h:1258
#define KSPROPERTY_TYPE_GET
Definition: dmksctrl.h:42
#define MIXERCONTROL_CONTROLF_UNIFORM
Definition: mmsystem.h:350
_In_ NDIS_HANDLE _In_ PNDIS_REQUEST Request
Definition: ndis.h:5173
#define MIXER_SETCONTROLDETAILSF_QUERYMASK
Definition: mmsystem.h:417
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
MIXER_CONTEXT MixerContext
Definition: mmixer.c:46
PMIXER_DEVICE_CONTROL Control
Definition: mmixer.h:95
#define MIXER_SETCONTROLDETAILSF_VALUE
Definition: mmsystem.h:415
DWORD dwComponentType
Definition: mmsystem.h:1261
void DPRINT(...)
Definition: polytest.cpp:61
struct tagMIXERCONTROLDETAILS_LISTTEXTW * LPMIXERCONTROLDETAILS_LISTTEXTW
VOID MMixerGetNextNodesFromNodeIndex(IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, IN ULONG NodeIndex, IN ULONG bUpStream, OUT PULONG OutNodesCount, OUT PULONG OutNodes)
Definition: topology.c:972
PMIXER_FREE Free
Definition: mmixer.h:96
__wchar_t WCHAR
Definition: xmlstorage.h:180
PTOPOLOGY Topology
Definition: precomp.h:118
static const UCHAR Index[8]
Definition: usbohci.c:18
#define MIXER_GETCONTROLDETAILSF_QUERYMASK
Definition: mmsystem.h:414
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
const GUID KSPROPSETID_Audio
Definition: sup.c:29
VOID MMixerGetLowestLogicalTopologyPinOffsetFromArray(IN ULONG LogicalPinArrayCount, IN PULONG LogicalPinArray, OUT PULONG PinOffset)
Definition: sup.c:91
Status
Definition: gdiplustypes.h:24
#define MAXULONG
Definition: typedefs.h:250
MIXER_STATUS
Definition: mmixer.h:3
WCHAR szName[MIXER_LONG_NAME_CHARS]
Definition: mmsystem.h:1266
_In_ FILTER_INFORMATION_CLASS _In_ ULONG _Out_ PULONG BytesReturned
Definition: fltkernel.h:1716
unsigned int * PULONG
Definition: retypes.h:1
#define DPRINT1
Definition: precomp.h:8
static const WCHAR szName[]
Definition: msipriv.h:1194
VOID MMixerGetConnectedFromLogicalTopologyPins(IN PTOPOLOGY Topology, IN ULONG NodeIndex, OUT PULONG OutPinCount, OUT PULONG OutPins)
Definition: topology.c:1165
LPMIXER_INFO MixerInfo
Definition: precomp.h:119
unsigned int ULONG
Definition: retypes.h:1
#define KSPROPERTY_TYPE_TOPOLOGY
Definition: dmksctrl.h:53
PMIXER_COPY Copy
Definition: mmixer.h:99
#define KSPROPERTY_TYPE_SET
Definition: dmksctrl.h:43
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
MIXER_STATUS MMixerAllocateTopologyNodeArray(IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, OUT PULONG *OutPins)
Definition: topology.c:1052
#define MM_MIXM_CONTROL_CHANGE
Definition: mmsystem.h:83

◆ MMixerSetGetVolumeControlDetails()

MIXER_STATUS MMixerSetGetVolumeControlDetails ( IN PMIXER_CONTEXT  MixerContext,
IN LPMIXER_INFO  MixerInfo,
IN ULONG  NodeId,
IN ULONG  bSet,
LPMIXERCONTROL_EXT  MixerControl,
IN LPMIXERCONTROLDETAILS  MixerControlDetails,
LPMIXERLINE_EXT  MixerLine 
)

Definition at line 668 of file sup.c.

676 {
678  LONG Value;
679  ULONG Index, Channel = 0;
680  ULONG dwValue;
682  LPMIXERVOLUME_DATA VolumeData;
683 
684  if (MixerControlDetails->cbDetails != sizeof(MIXERCONTROLDETAILS_SIGNED))
686 
687  VolumeData = (LPMIXERVOLUME_DATA)MixerControl->ExtraData;
688  if (!VolumeData)
689  return MM_STATUS_UNSUCCESSFUL;
690 
691  /* get input */
692  Input = (LPMIXERCONTROLDETAILS_UNSIGNED)MixerControlDetails->paDetails;
693 
694  if (bSet)
695  {
696  /* FIXME SEH */
697  Value = Input->dwValue;
698  Index = Value / VolumeData->InputSteppingDelta;
699 
700  if (Index >= VolumeData->ValuesCount)
701  {
702  DPRINT1("Index %u out of bounds %u \n", Index, VolumeData->ValuesCount);
704  }
705 
706  Value = VolumeData->Values[Index];
707  }
708 
709  /* set control details */
710  if (bSet)
711  {
712  /* TODO */
715  }
716  else
717  {
718  Status = MMixerSetGetControlDetails(MixerContext, MixerControl->hDevice, NodeId, bSet, KSPROPERTY_AUDIO_VOLUMELEVEL, Channel, &Value);
719  }
720 
721  if (!bSet)
722  {
723  dwValue = MMixerGetVolumeControlIndex(VolumeData, (LONG)Value);
724  /* FIXME SEH */
725  Input->dwValue = dwValue;
726  }
727  else
728  {
729  /* notify clients of a line change MM_MIXM_CONTROL_CHANGE with MixerControl->dwControlID */
731  }
732  return Status;
733 }
_In_opt_ ULONG _Out_ PULONG Value
Definition: rtlfuncs.h:2327
VOID MMixerNotifyControlChange(IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN ULONG NotificationType, IN ULONG Value)
Definition: sup.c:339
MIXERCONTROLW Control
Definition: precomp.h:79
Definition: arc.h:84
ULONG ValuesCount
Definition: precomp.h:107
MIXER_CONTEXT MixerContext
Definition: mmixer.c:46
long LONG
Definition: pedump.c:60
PVOID ExtraData
Definition: precomp.h:82
HANDLE hDevice
Definition: precomp.h:81
if(!(yy_init))
Definition: macro.lex.yy.c:714
static const UCHAR Index[8]
Definition: usbohci.c:18
struct tMIXERCONTROLDETAILS_UNSIGNED * LPMIXERCONTROLDETAILS_UNSIGNED
MIXER_STATUS MMixerSetGetControlDetails(IN PMIXER_CONTEXT MixerContext, IN HANDLE hMixer, IN ULONG NodeId, IN ULONG bSet, IN ULONG PropertyId, IN ULONG Channel, IN PLONG InputValue)
Definition: filter.c:219
struct MIXERVOLUME_DATA * LPMIXERVOLUME_DATA
Status
Definition: gdiplustypes.h:24
MIXER_STATUS
Definition: mmixer.h:3
#define DPRINT1
Definition: precomp.h:8
unsigned int ULONG
Definition: retypes.h:1
ULONG InputSteppingDelta
Definition: precomp.h:106
ULONG MMixerGetVolumeControlIndex(LPMIXERVOLUME_DATA VolumeData, LONG Value)
Definition: sup.c:322
#define MM_MIXM_CONTROL_CHANGE
Definition: mmsystem.h:83

Referenced by MMixerGetControlDetails(), and MMixerSetControlDetails().

◆ MMixerVerifyContext()

MIXER_STATUS MMixerVerifyContext ( IN PMIXER_CONTEXT  MixerContext)

Definition at line 41 of file sup.c.

43 {
44  if (MixerContext->SizeOfStruct != sizeof(MIXER_CONTEXT))
46 
51 
54 
55  return MM_STATUS_SUCCESS;
56 }
ULONG SizeOfStruct
Definition: mmixer.h:91
PMIXER_OPEN_KEY OpenKey
Definition: mmixer.h:100
PMIXER_CLOSE Close
Definition: mmixer.h:98
MIXER_CONTEXT MixerContext
Definition: mmixer.c:46
PMIXER_DEVICE_CONTROL Control
Definition: mmixer.h:95
PMIXER_ALLOC_EVENT_DATA AllocEventData
Definition: mmixer.h:103
PMIXER_FREE_EVENT_DATA FreeEventData
Definition: mmixer.h:104
PMIXER_FREE Free
Definition: mmixer.h:96
PMIXER_QUERY_KEY_VALUE QueryKeyValue
Definition: mmixer.h:101
PMIXER_ALLOC Alloc
Definition: mmixer.h:94
PVOID MixerContext
Definition: mmixer.h:92
PMIXER_CLOSEKEY CloseKey
Definition: mmixer.h:102
PMIXER_OPEN Open
Definition: mmixer.h:97

Referenced by MMixerClose(), MMixerGetCapabilities(), MMixerGetControlDetails(), MMixerGetCount(), MMixerGetLineControls(), MMixerGetLineInfo(), MMixerGetMidiDevicePath(), MMixerGetMidiInCount(), MMixerGetMidiOutCount(), MMixerGetWaveDevicePath(), MMixerGetWaveInCount(), MMixerGetWaveOutCount(), MMixerMidiInCapabilities(), MMixerMidiOutCapabilities(), MMixerOpen(), MMixerOpenMidi(), MMixerOpenWave(), MMixerSetControlDetails(), MMixerSetWaveResetState(), MMixerSetWaveStatus(), MMixerWaveInCapabilities(), and MMixerWaveOutCapabilities().

Variable Documentation

◆ KSDATAFORMAT_SPECIFIER_NONE

const GUID KSDATAFORMAT_SPECIFIER_NONE = {0x0F6417D6L, 0xC318, 0x11D0, {0xA4, 0x3F, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}}

Definition at line 37 of file sup.c.

Referenced by MMixerCheckFilterPinMidiSupport(), and MMixerOpenMidiPin().

◆ KSDATAFORMAT_SUBTYPE_MIDI

const GUID KSDATAFORMAT_SUBTYPE_MIDI = {0x1D262760L, 0xE957, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}}

◆ KSDATAFORMAT_TYPE_MUSIC

const GUID KSDATAFORMAT_TYPE_MUSIC = {0xE725D360L, 0x62CC, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}}

Definition at line 35 of file sup.c.

Referenced by MMixerCheckFilterPinMidiSupport(), and MMixerOpenMidiPin().

◆ KSEVENTSETID_AudioControlChange

const GUID KSEVENTSETID_AudioControlChange = {0xE85E9698L, 0xFA2F, 0x11D1, {0x95, 0xBD, 0x00, 0xC0, 0x4F, 0xB9, 0x25, 0xD3}}

Definition at line 33 of file sup.c.

Referenced by MMixerAddEvent().

◆ KSNODETYPE_ADC

const GUID KSNODETYPE_ADC = {0x4D837FE0L, 0xC555, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

Definition at line 16 of file sup.c.

Referenced by BuildUSBAudioFilterTopology(), and MMixerSetupFilter().

◆ KSNODETYPE_AGC

const GUID KSNODETYPE_AGC = {0xE88C9BA0L, 0xC557, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

Definition at line 17 of file sup.c.

Referenced by BuildUSBAudioFilterTopology(), and MMixerGetControlTypeFromTopologyNode().

◆ KSNODETYPE_CHORUS

const GUID KSNODETYPE_CHORUS = {0x20173F20L, 0xC559, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

Definition at line 25 of file sup.c.

Referenced by MMixerGetControlTypeFromTopologyNode().

◆ KSNODETYPE_DAC

const GUID KSNODETYPE_DAC = {0x507AE360L, 0xC554, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

Definition at line 15 of file sup.c.

Referenced by BuildUSBAudioFilterTopology(), and MMixerSetupFilter().

◆ KSNODETYPE_LOUDNESS

const GUID KSNODETYPE_LOUDNESS = {0x41887440L, 0xC558, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

Definition at line 18 of file sup.c.

Referenced by MMixerGetControlTypeFromTopologyNode().

◆ KSNODETYPE_MUTE

const GUID KSNODETYPE_MUTE = {0x02B223C0L, 0xC557, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

Definition at line 19 of file sup.c.

Referenced by BuildUSBAudioFilterTopology(), and MMixerGetControlTypeFromTopologyNode().

◆ KSNODETYPE_MUX

const GUID KSNODETYPE_MUX = {0x2CEAF780, 0xC556, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

◆ KSNODETYPE_PEAKMETER

const GUID KSNODETYPE_PEAKMETER = {0xa085651e, 0x5f0d, 0x4b36, {0xa8, 0x69, 0xd1, 0x95, 0xd6, 0xab, 0x4b, 0x9e}}

Definition at line 22 of file sup.c.

Referenced by MMixerGetControlTypeFromTopologyNode().

◆ KSNODETYPE_REVERB

const GUID KSNODETYPE_REVERB = {0xEF0328E0L, 0xC558, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

Definition at line 26 of file sup.c.

Referenced by MMixerGetControlTypeFromTopologyNode().

◆ KSNODETYPE_STEREO_WIDE

const GUID KSNODETYPE_STEREO_WIDE = {0xA9E69800L, 0xC558, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

Definition at line 24 of file sup.c.

Referenced by MMixerGetControlTypeFromTopologyNode().

◆ KSNODETYPE_SUM

const GUID KSNODETYPE_SUM = {0xDA441A60L, 0xC556, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

Definition at line 14 of file sup.c.

Referenced by BuildUSBAudioFilterTopology(), and MMixerIsNodeTerminator().

◆ KSNODETYPE_SUPERMIX

const GUID KSNODETYPE_SUPERMIX = {0xE573ADC0L, 0xC555, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

Definition at line 27 of file sup.c.

Referenced by BuildUSBAudioFilterTopology(), and MMixerGetControlTypeFromTopologyNode().

◆ KSNODETYPE_TONE

const GUID KSNODETYPE_TONE = {0x7607E580L, 0xC557, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

Definition at line 20 of file sup.c.

Referenced by BuildUSBAudioFilterTopology(), and MMixerGetControlTypeFromTopologyNode().

◆ KSNODETYPE_VOLUME

const GUID KSNODETYPE_VOLUME = {0x3A5ACC00L, 0xC557, 0x11D0, {0x8A, 0x2B, 0x00, 0xA0, 0xC9, 0x25, 0x5A, 0xC1}}

◆ KSPROPSETID_Audio

const GUID KSPROPSETID_Audio = {0x45FFAAA0L, 0x6E1B, 0x11D0, {0xBC, 0xF2, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}}

Definition at line 29 of file sup.c.

Referenced by MMixerSetGetMuxControlDetails().

◆ KSPROPSETID_General

const GUID KSPROPSETID_General = {0x1464EDA5L, 0x6A8F, 0x11D1, {0x9A, 0xA7, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}}

Definition at line 31 of file sup.c.

Referenced by MMixerGetDeviceNameWithComponentId().

◆ KSPROPSETID_Pin

const GUID KSPROPSETID_Pin = {0x8C134960L, 0x51AD, 0x11CF, {0x87, 0x8A, 0x94, 0xF8, 0x01, 0xC1, 0x00, 0x00}}

Definition at line 30 of file sup.c.

◆ KSPROPSETID_Topology

const GUID KSPROPSETID_Topology = {0x720D4AC0L, 0x7533, 0x11D0, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}}

Definition at line 32 of file sup.c.