ReactOS 0.4.15-dev-7931-gfd331f1
mmixer.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  MIXER_CONTEXT
 

Typedefs

typedef PVOID(* PMIXER_ALLOC) (IN ULONG NumberOfBytes)
 
typedef VOID(* PMIXER_FREE) (IN PVOID Block)
 
typedef MIXER_STATUS(* PMIXER_ENUM) (IN PVOID EnumContext, IN ULONG DeviceIndex, OUT LPWSTR *DeviceName, OUT PHANDLE OutHandle, OUT PHANDLE OutDevInterfaceKey)
 
typedef MIXER_STATUS(* PMIXER_DEVICE_CONTROL) (IN HANDLE hMixer, IN ULONG dwIoControlCode, IN PVOID lpInBuffer, IN ULONG nInBufferSize, OUT PVOID lpOutBuffer, ULONG nOutBufferSize, PULONG lpBytesReturned)
 
typedef MIXER_STATUS(* PMIXER_OPEN) (IN LPWSTR DevicePath, OUT PHANDLE hDevice)
 
typedef MIXER_STATUS(* PMIXER_CLOSE) (IN HANDLE hDevice)
 
typedef MIXER_STATUS(* PMIXER_CLOSEKEY) (IN HANDLE hKey)
 
typedef VOID(CALLBACKPMIXER_EVENT) (IN PVOID MixerEventContext, IN HANDLE hMixer, IN ULONG NotificationType, IN ULONG Value)
 
typedef VOID(* PMIXER_COPY) (IN PVOID Dst, IN PVOID Src, IN ULONG Length)
 
typedef MIXER_STATUS(* PMIXER_QUERY_KEY_VALUE) (IN HANDLE hKey, IN LPWSTR KeyName, OUT PVOID *ResultBuffer, OUT PULONG ResultLength, OUT PULONG KeyType)
 
typedef MIXER_STATUS(* PMIXER_OPEN_KEY) (IN HANDLE hKey, IN LPWSTR SubKey, IN ULONG DesiredAccess, OUT PHANDLE OutKey)
 
typedef PVOID(* PMIXER_ALLOC_EVENT_DATA) (IN ULONG ExtraBytes)
 
typedef VOID(* PMIXER_FREE_EVENT_DATA) (IN PVOID EventData)
 
typedef MIXER_STATUS(* PIN_CREATE_CALLBACK) (IN PVOID Context, IN ULONG DeviceId, IN ULONG PinId, IN HANDLE hFilter, IN PKSPIN_CONNECT PinConnect, IN ACCESS_MASK DesiredAccess, OUT PHANDLE PinHandle)
 
typedef struct MIXER_CONTEXTPMIXER_CONTEXT
 

Enumerations

enum  MIXER_STATUS {
  MM_STATUS_SUCCESS = 0 , MM_STATUS_NOTINITIALIZED , MM_STATUS_NOT_IMPLEMENTED , MM_STATUS_NO_MORE_DEVICES ,
  MM_STATUS_MORE_ENTRIES , MM_STATUS_INVALID_PARAMETER , MM_STATUS_UNSUCCESSFUL , MM_STATUS_NO_MEMORY
}
 

Functions

MIXER_STATUS MMixerInitialize (IN PMIXER_CONTEXT MixerContext, IN PMIXER_ENUM EnumFunction, IN PVOID EnumContext)
 
ULONG MMixerGetCount (IN PMIXER_CONTEXT MixerContext)
 
ULONG MMixerGetWaveInCount (IN PMIXER_CONTEXT MixerContext)
 
ULONG MMixerGetWaveOutCount (IN PMIXER_CONTEXT MixerContext)
 
ULONG MMixerGetMidiInCount (IN PMIXER_CONTEXT MixerContext)
 
ULONG MMixerGetMidiOutCount (IN PMIXER_CONTEXT MixerContext)
 
MIXER_STATUS MMixerGetCapabilities (IN PMIXER_CONTEXT MixerContext, IN ULONG MixerIndex, OUT LPMIXERCAPSW MixerCaps)
 
MIXER_STATUS MMixerOpen (IN PMIXER_CONTEXT MixerContext, IN ULONG MixerId, IN PVOID MixerEventContext, IN PMIXER_EVENT MixerEventRoutine, OUT PHANDLE MixerHandle)
 
MIXER_STATUS MMixerClose (IN PMIXER_CONTEXT MixerContext, IN ULONG MixerId, IN PVOID MixerEventContext, IN PMIXER_EVENT MixerEventRoutine)
 
MIXER_STATUS MMixerGetLineInfo (IN PMIXER_CONTEXT MixerContext, IN HANDLE MixerHandle, IN ULONG MixerId, IN ULONG Flags, OUT LPMIXERLINEW MixerLine)
 
MIXER_STATUS MMixerGetLineControls (IN PMIXER_CONTEXT MixerContext, IN HANDLE MixerHandle, IN ULONG MixerId, IN ULONG Flags, OUT LPMIXERLINECONTROLSW MixerLineControls)
 
MIXER_STATUS MMixerSetControlDetails (IN PMIXER_CONTEXT MixerContext, IN HANDLE MixerHandle, IN ULONG MixerId, IN ULONG Flags, OUT LPMIXERCONTROLDETAILS MixerControlDetails)
 
MIXER_STATUS MMixerGetControlDetails (IN PMIXER_CONTEXT MixerContext, IN HANDLE MixerHandle, IN ULONG MixerId, IN ULONG Flags, OUT LPMIXERCONTROLDETAILS MixerControlDetails)
 
MIXER_STATUS MMixerWaveOutCapabilities (IN PMIXER_CONTEXT MixerContext, IN ULONG DeviceIndex, OUT LPWAVEOUTCAPSW Caps)
 
MIXER_STATUS MMixerWaveInCapabilities (IN PMIXER_CONTEXT MixerContext, IN ULONG DeviceIndex, OUT LPWAVEINCAPSW Caps)
 
MIXER_STATUS MMixerOpenWave (IN PMIXER_CONTEXT MixerContext, IN ULONG DeviceIndex, IN ULONG bWaveIn, IN LPWAVEFORMATEX WaveFormat, IN PIN_CREATE_CALLBACK CreateCallback, IN PVOID Context, OUT PHANDLE PinHandle)
 
MIXER_STATUS MMixerSetWaveStatus (IN PMIXER_CONTEXT MixerContext, IN HANDLE PinHandle, IN KSSTATE State)
 
MIXER_STATUS MMixerSetWaveResetState (IN PMIXER_CONTEXT MixerContext, IN HANDLE PinHandle, IN ULONG bBegin)
 
MIXER_STATUS MMixerGetWaveDevicePath (IN PMIXER_CONTEXT MixerContext, IN ULONG bWaveIn, IN ULONG DeviceId, OUT LPWSTR *DevicePath)
 
MIXER_STATUS MMixerMidiOutCapabilities (IN PMIXER_CONTEXT MixerContext, IN ULONG DeviceIndex, OUT LPMIDIOUTCAPSW Caps)
 
MIXER_STATUS MMixerMidiInCapabilities (IN PMIXER_CONTEXT MixerContext, IN ULONG DeviceIndex, OUT LPMIDIINCAPSW Caps)
 
MIXER_STATUS MMixerGetMidiDevicePath (IN PMIXER_CONTEXT MixerContext, IN ULONG bMidiIn, IN ULONG DeviceId, OUT LPWSTR *DevicePath)
 
MIXER_STATUS MMixerSetMidiStatus (IN PMIXER_CONTEXT MixerContext, IN HANDLE PinHandle, IN KSSTATE State)
 
MIXER_STATUS MMixerOpenMidi (IN PMIXER_CONTEXT MixerContext, IN ULONG DeviceIndex, IN ULONG bMidiIn, IN PIN_CREATE_CALLBACK CreateCallback, IN PVOID Context, OUT PHANDLE PinHandle)
 

Typedef Documentation

◆ PIN_CREATE_CALLBACK

typedef MIXER_STATUS(* PIN_CREATE_CALLBACK) (IN PVOID Context, IN ULONG DeviceId, IN ULONG PinId, IN HANDLE hFilter, IN PKSPIN_CONNECT PinConnect, IN ACCESS_MASK DesiredAccess, OUT PHANDLE PinHandle)

Definition at line 80 of file mmixer.h.

◆ PMIXER_ALLOC

typedef PVOID(* PMIXER_ALLOC) (IN ULONG NumberOfBytes)

Definition at line 18 of file mmixer.h.

◆ PMIXER_ALLOC_EVENT_DATA

typedef PVOID(* PMIXER_ALLOC_EVENT_DATA) (IN ULONG ExtraBytes)

Definition at line 74 of file mmixer.h.

◆ PMIXER_CLOSE

typedef MIXER_STATUS(* PMIXER_CLOSE) (IN HANDLE hDevice)

Definition at line 44 of file mmixer.h.

◆ PMIXER_CLOSEKEY

typedef MIXER_STATUS(* PMIXER_CLOSEKEY) (IN HANDLE hKey)

Definition at line 47 of file mmixer.h.

◆ PMIXER_CONTEXT

◆ PMIXER_COPY

typedef VOID(* PMIXER_COPY) (IN PVOID Dst, IN PVOID Src, IN ULONG Length)

Definition at line 56 of file mmixer.h.

◆ PMIXER_DEVICE_CONTROL

typedef MIXER_STATUS(* PMIXER_DEVICE_CONTROL) (IN HANDLE hMixer, IN ULONG dwIoControlCode, IN PVOID lpInBuffer, IN ULONG nInBufferSize, OUT PVOID lpOutBuffer, ULONG nOutBufferSize, PULONG lpBytesReturned)

Definition at line 31 of file mmixer.h.

◆ PMIXER_ENUM

typedef MIXER_STATUS(* PMIXER_ENUM) (IN PVOID EnumContext, IN ULONG DeviceIndex, OUT LPWSTR *DeviceName, OUT PHANDLE OutHandle, OUT PHANDLE OutDevInterfaceKey)

Definition at line 24 of file mmixer.h.

◆ PMIXER_EVENT

typedef VOID(CALLBACK * PMIXER_EVENT) (IN PVOID MixerEventContext, IN HANDLE hMixer, IN ULONG NotificationType, IN ULONG Value)

Definition at line 50 of file mmixer.h.

◆ PMIXER_FREE

typedef VOID(* PMIXER_FREE) (IN PVOID Block)

Definition at line 21 of file mmixer.h.

◆ PMIXER_FREE_EVENT_DATA

typedef VOID(* PMIXER_FREE_EVENT_DATA) (IN PVOID EventData)

Definition at line 77 of file mmixer.h.

◆ PMIXER_OPEN

typedef MIXER_STATUS(* PMIXER_OPEN) (IN LPWSTR DevicePath, OUT PHANDLE hDevice)

Definition at line 40 of file mmixer.h.

◆ PMIXER_OPEN_KEY

typedef MIXER_STATUS(* PMIXER_OPEN_KEY) (IN HANDLE hKey, IN LPWSTR SubKey, IN ULONG DesiredAccess, OUT PHANDLE OutKey)

Definition at line 68 of file mmixer.h.

◆ PMIXER_QUERY_KEY_VALUE

typedef MIXER_STATUS(* PMIXER_QUERY_KEY_VALUE) (IN HANDLE hKey, IN LPWSTR KeyName, OUT PVOID *ResultBuffer, OUT PULONG ResultLength, OUT PULONG KeyType)

Definition at line 61 of file mmixer.h.

Enumeration Type Documentation

◆ MIXER_STATUS

Enumerator
MM_STATUS_SUCCESS 
MM_STATUS_NOTINITIALIZED 
MM_STATUS_NOT_IMPLEMENTED 
MM_STATUS_NO_MORE_DEVICES 
MM_STATUS_MORE_ENTRIES 
MM_STATUS_INVALID_PARAMETER 
MM_STATUS_UNSUCCESSFUL 
MM_STATUS_NO_MEMORY 

Definition at line 3 of file mmixer.h.

4{
13
14
MIXER_STATUS
Definition: mmixer.h:4
@ MM_STATUS_NOT_IMPLEMENTED
Definition: mmixer.h:7
@ MM_STATUS_UNSUCCESSFUL
Definition: mmixer.h:11
@ MM_STATUS_INVALID_PARAMETER
Definition: mmixer.h:10
@ MM_STATUS_NO_MEMORY
Definition: mmixer.h:12
@ MM_STATUS_NOTINITIALIZED
Definition: mmixer.h:6
@ MM_STATUS_SUCCESS
Definition: mmixer.h:5
@ MM_STATUS_NO_MORE_DEVICES
Definition: mmixer.h:8
@ MM_STATUS_MORE_ENTRIES
Definition: mmixer.h:9

Function Documentation

◆ MMixerClose()

MIXER_STATUS MMixerClose ( IN PMIXER_CONTEXT  MixerContext,
IN ULONG  MixerId,
IN PVOID  MixerEventContext,
IN PMIXER_EVENT  MixerEventRoutine 
)

Definition at line 115 of file mixer.c.

120{
122 LPMIXER_INFO MixerInfo;
123
124 /* verify mixer context */
126
128 {
129 /* invalid context passed */
130 DPRINT1("invalid context\n");
131 return Status;
132 }
133
134 /* get mixer info */
135 MixerInfo = MMixerGetMixerInfoByIndex(MixerContext, MixerId);
136 if (!MixerInfo)
137 {
138 /* invalid mixer id */
139 DPRINT1("invalid mixer id %lu\n", MixerId);
141 }
142
143 /* remove event from list */
144 return MMixerRemoveEvent(MixerContext, MixerInfo, MixerEventContext, MixerEventRoutine);
145}
#define DPRINT1
Definition: precomp.h:8
MIXER_STATUS MMixerRemoveEvent(IN PMIXER_CONTEXT MixerContext, IN OUT LPMIXER_INFO MixerInfo, IN PVOID MixerEventContext, IN PMIXER_EVENT MixerEventRoutine)
Definition: controls.c:1875
MIXER_CONTEXT MixerContext
Definition: mmixer.c:41
Status
Definition: gdiplustypes.h:25
LPMIXER_INFO MMixerGetMixerInfoByIndex(IN PMIXER_CONTEXT MixerContext, IN ULONG MixerIndex)
Definition: sup.c:158
MIXER_STATUS MMixerVerifyContext(IN PMIXER_CONTEXT MixerContext)
Definition: sup.c:40

Referenced by WdmAudCloseAllMixers(), and WdmAudControlCloseMixer().

◆ MMixerGetCapabilities()

MIXER_STATUS MMixerGetCapabilities ( IN PMIXER_CONTEXT  MixerContext,
IN ULONG  MixerIndex,
OUT LPMIXERCAPSW  MixerCaps 
)

Definition at line 38 of file mixer.c.

42{
44 LPMIXER_INFO MixerInfo;
45
46 /* verify mixer context */
48
50 {
51 /* invalid context passed */
52 return Status;
53 }
54
55 /* get mixer info */
56 MixerInfo = MMixerGetMixerInfoByIndex(MixerContext, MixerIndex);
57
58 if (!MixerInfo)
59 {
60 // invalid device index
62 }
63
64 MixerCaps->wMid = MixerInfo->MixCaps.wMid;
65 MixerCaps->wPid = MixerInfo->MixCaps.wPid;
66 MixerCaps->vDriverVersion = MixerInfo->MixCaps.vDriverVersion;
67 MixerCaps->fdwSupport = MixerInfo->MixCaps.fdwSupport;
68 MixerCaps->cDestinations = MixerInfo->MixCaps.cDestinations;
69
70 ASSERT(MixerInfo->MixCaps.szPname[MAXPNAMELEN-1] == 0);
71 wcscpy(MixerCaps->szPname, MixerInfo->MixCaps.szPname);
72
73 return MM_STATUS_SUCCESS;
74}
#define MAXPNAMELEN
Definition: mmsystem.h:24
#define ASSERT(a)
Definition: mode.c:44
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
MIXERCAPSW MixCaps
Definition: precomp.h:70
DWORD cDestinations
Definition: mmsystem.h:1228
MMVERSION vDriverVersion
Definition: mmsystem.h:1225
DWORD fdwSupport
Definition: mmsystem.h:1227
WCHAR szPname[MAXPNAMELEN]
Definition: mmsystem.h:1226

Referenced by WdmAudGetMixerCapabilities(), and WdmAudMixerCapabilities().

◆ MMixerGetControlDetails()

MIXER_STATUS MMixerGetControlDetails ( IN PMIXER_CONTEXT  MixerContext,
IN HANDLE  MixerHandle,
IN ULONG  MixerId,
IN ULONG  Flags,
OUT LPMIXERCONTROLDETAILS  MixerControlDetails 
)

Definition at line 565 of file mixer.c.

571{
573 ULONG NodeId;
574 LPMIXER_INFO MixerInfo;
575 LPMIXERLINE_EXT MixerLine;
576 LPMIXERCONTROL_EXT MixerControl;
577
578 /* verify mixer context */
580
582 {
583 /* invalid context passed */
584 return Status;
585 }
586
588 {
589 /* caller passed mixer id */
590 MixerHandle = (HANDLE)MMixerGetMixerInfoByIndex(MixerContext, MixerId);
591
592 if (!MixerHandle)
593 {
594 /* invalid parameter */
596 }
597 }
598
599 /* get mixer info */
600 MixerInfo = (LPMIXER_INFO)MixerHandle;
601
602 /* get mixer control */
603 Status = MMixerGetMixerControlById(MixerInfo, MixerControlDetails->dwControlID, &MixerLine, &MixerControl, &NodeId);
604
605 /* check for success */
607 {
608 /* failed to find control id */
610 }
611
612 switch(MixerControl->Control.dwControlType)
613 {
615 Status = MMixerSetGetMuteControlDetails(MixerContext, MixerInfo, MixerControl, MixerLine->Line.dwLineID, MixerControlDetails, FALSE);
616 break;
618 Status = MMixerSetGetVolumeControlDetails(MixerContext, MixerInfo, NodeId, FALSE, MixerControl, MixerControlDetails, MixerLine);
619 break;
621 DPRINT1("Not Implemented MIXERCONTROL_CONTROLTYPE_ONOFF\n");
622 break;
624 Status = MMixerSetGetMuxControlDetails(MixerContext, MixerInfo, NodeId, FALSE, Flags, MixerControl, MixerControlDetails, MixerLine);
625 break;
626
627 default:
629 DPRINT1("ControlType %lx not implemented\n", MixerControl->Control.dwControlType);
630 }
631
632 return Status;
633}
#define FALSE
Definition: types.h:117
#define MIXER_OBJECTF_MIXER
Definition: mmsystem.h:300
#define MIXERCONTROL_CONTROLTYPE_ONOFF
Definition: mmsystem.h:383
#define MIXERCONTROL_CONTROLTYPE_MUX
Definition: mmsystem.h:403
#define MIXERCONTROL_CONTROLTYPE_VOLUME
Definition: mmsystem.h:398
#define MIXER_OBJECTF_HMIXER
Definition: mmsystem.h:301
#define MIXERCONTROL_CONTROLTYPE_MUTE
Definition: mmsystem.h:384
MIXER_STATUS MMixerSetGetMuxControlDetails(IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN ULONG NodeId, IN ULONG bSet, IN ULONG Flags, LPMIXERCONTROL_EXT MixerControl, IN LPMIXERCONTROLDETAILS MixerControlDetails, LPMIXERLINE_EXT MixerLine)
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: sup.c:364
MIXER_STATUS MMixerGetMixerControlById(LPMIXER_INFO MixerInfo, DWORD dwControlID, LPMIXERLINE_EXT *MixerLine, LPMIXERCONTROL_EXT *MixerControl, PULONG NodeId)
Definition: sup.c:278
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: sup.c:665
struct MIXER_INFO * LPMIXER_INFO
MIXERCONTROLW Control
Definition: precomp.h:79
MIXERLINEW Line
Definition: precomp.h:89
DWORD dwControlType
Definition: mmsystem.h:1306
DWORD dwLineID
Definition: mmsystem.h:1258
PVOID HANDLE
Definition: typedefs.h:73
uint32_t ULONG
Definition: typedefs.h:59
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

Referenced by WdmAudGetControlDetails().

◆ MMixerGetCount()

ULONG MMixerGetCount ( IN PMIXER_CONTEXT  MixerContext)

Definition at line 15 of file mixer.c.

17{
18 PMIXER_LIST MixerList;
20
21 /* verify mixer context */
23
25 {
26 /* invalid context passed */
27 return Status;
28 }
29
30 /* grab mixer list */
32
33 // return number of mixers
34 return MixerList->MixerListCount;
35}
struct MIXER_LIST * PMIXER_LIST
PVOID MixerContext
Definition: mmixer.h:92
ULONG MixerListCount
Definition: precomp.h:149

Referenced by WdmAudGetMixerDeviceCount(), and WdmAudGetNumWdmDevsByMMixer().

◆ MMixerGetLineControls()

MIXER_STATUS MMixerGetLineControls ( IN PMIXER_CONTEXT  MixerContext,
IN HANDLE  MixerHandle,
IN ULONG  MixerId,
IN ULONG  Flags,
OUT LPMIXERLINECONTROLSW  MixerLineControls 
)

Definition at line 331 of file mixer.c.

337{
338 LPMIXER_INFO MixerInfo;
339 LPMIXERLINE_EXT MixerLineSrc;
340 LPMIXERCONTROL_EXT MixerControl;
343 ULONG Index;
344
345 /* verify mixer context */
347
349 {
350 /* invalid context passed */
351 return Status;
352 }
353
354 if (MixerLineControls->cbStruct != sizeof(MIXERLINECONTROLSW))
355 {
356 DPRINT1("Invalid MixerLineControls cbStruct passed %lu expected %lu\n", MixerLineControls->cbStruct, sizeof(MIXERLINECONTROLSW));
357 /* invalid parameter */
359 }
360
361 if (MixerLineControls->cbmxctrl != sizeof(MIXERCONTROLW))
362 {
363 DPRINT1("Invalid MixerLineControls cbmxctrl passed %lu expected %lu\n", MixerLineControls->cbmxctrl, sizeof(MIXERCONTROLW));
364 /* invalid parameter */
366 }
367
369 {
370 /* caller passed mixer id */
371 MixerHandle = (HANDLE)MMixerGetMixerInfoByIndex(MixerContext, MixerId);
372
373 if (!MixerHandle)
374 {
375 /* invalid parameter */
377 }
378 }
379
380 Flags &= ~MIXER_OBJECTF_HMIXER;
381
382 DPRINT("MMixerGetLineControls MixerId %lu Flags %lu\n", MixerId, Flags);
383
385 {
386 /* cast to mixer info */
387 MixerInfo = (LPMIXER_INFO)MixerHandle;
388
389 /* get mixer line */
390 MixerLineSrc = MMixerGetSourceMixerLineByLineId(MixerInfo, MixerLineControls->dwLineID);
391
392 if (!MixerLineSrc)
393 {
394 /* invalid line id */
395 DPRINT("MMixerGetLineControls Line not found %lx\n", MixerLineControls->dwLineID);
397 }
398
399 if (MixerLineSrc->Line.cControls != MixerLineControls->cControls)
400 {
401 /* invalid parameter */
402 DPRINT1("Invalid control count %lu expected %lu\n", MixerLineControls->cControls, MixerLineSrc->Line.cControls);
404 }
405
406 /* copy line control(s) */
407 Entry = MixerLineSrc->ControlsList.Flink;
408 Index = 0;
409 while(Entry != &MixerLineSrc->ControlsList)
410 {
411 /* get mixer control */
413
414 /* copy mixer control */
415 MixerContext->Copy(&MixerLineControls->pamxctrl[Index], &MixerControl->Control, sizeof(MIXERCONTROLW));
416
417 /* move to next */
418 Entry = Entry->Flink;
419
420 /* increment mixer control offset */
421 Index++;
422 }
423 return MM_STATUS_SUCCESS;
424 }
426 {
427 /* cast to mixer info */
428 MixerInfo = (LPMIXER_INFO)MixerHandle;
429
430 /* get mixer line */
431 MixerLineSrc = MMixerGetSourceMixerLineByLineId(MixerInfo, MixerLineControls->dwLineID);
432
433 if (!MixerLineSrc)
434 {
435 /* invalid line id */
436 DPRINT1("MMixerGetLineControls Line not found %lx\n", MixerLineControls->dwLineID);
438 }
439
440 /* sanity checks */
441 ASSERT(MixerLineControls->cControls == 1);
442 ASSERT(MixerLineControls->cbmxctrl == sizeof(MIXERCONTROLW));
443 ASSERT(MixerLineControls->pamxctrl != NULL);
444
445 Entry = MixerLineSrc->ControlsList.Flink;
446 while(Entry != &MixerLineSrc->ControlsList)
447 {
449 if (MixerLineControls->dwControlType == MixerControl->Control.dwControlType)
450 {
451 /* found a control with that type */
452 MixerContext->Copy(MixerLineControls->pamxctrl, &MixerControl->Control, sizeof(MIXERCONTROLW));
453 return MM_STATUS_SUCCESS;
454 }
455
456 /* move to next entry */
457 Entry = Entry->Flink;
458 }
459
460 DPRINT("DeviceInfo->u.MixControls.dwControlType %x not found in Line %x cControls %u \n", MixerLineControls->dwControlType, MixerLineControls->dwLineID, MixerLineSrc->Line.cControls);
462 }
464 {
465 /* cast to mixer info */
466 MixerInfo = (LPMIXER_INFO)MixerHandle;
467
468 Status = MMixerGetMixerControlById(MixerInfo, MixerLineControls->dwControlID, NULL, &MixerControl, NULL);
469
471 {
472 /* invalid parameter */
473 DPRINT("MMixerGetLineControls ControlID not found %lx\n", MixerLineControls->dwLineID);
475 }
476
477 ASSERT(MixerLineControls->cControls == 1);
478 ASSERT(MixerLineControls->cbmxctrl == sizeof(MIXERCONTROLW));
479 ASSERT(MixerLineControls->pamxctrl != NULL);
480
481 DPRINT("MMixerGetLineControls ControlID %lx ControlType %lx Name %S\n", MixerControl->Control.dwControlID, MixerControl->Control.dwControlType, MixerControl->Control.szName);
482
483 /* copy the controls */
484 MixerContext->Copy(MixerLineControls->pamxctrl, &MixerControl->Control, sizeof(MIXERCONTROLW));
485 MixerLineControls->pamxctrl->szName[MIXER_LONG_NAME_CHARS-1] = L'\0';
486 MixerLineControls->pamxctrl->szShortName[MIXER_SHORT_NAME_CHARS-1] = L'\0';
487
488 return MM_STATUS_SUCCESS;
489 }
492}
#define UNIMPLEMENTED
Definition: debug.h:115
#define NULL
Definition: types.h:112
#define MIXER_GETLINECONTROLSF_ONEBYID
Definition: mmsystem.h:409
#define MIXER_LONG_NAME_CHARS
Definition: mmsystem.h:294
#define MIXER_GETLINECONTROLSF_ALL
Definition: mmsystem.h:408
#define MIXER_GETLINECONTROLSF_ONEBYTYPE
Definition: mmsystem.h:410
#define MIXER_SHORT_NAME_CHARS
Definition: mmsystem.h:293
#define L(x)
Definition: ntvdm.h:50
struct MIXERCONTROL_EXT * LPMIXERCONTROL_EXT
LPMIXERLINE_EXT MMixerGetSourceMixerLineByLineId(LPMIXER_INFO MixerInfo, DWORD dwLineID)
Definition: sup.c:218
#define DPRINT
Definition: sndvol32.h:71
base of all file and directory entries
Definition: entries.h:83
LIST_ENTRY ControlsList
Definition: precomp.h:90
PMIXER_COPY Copy
Definition: mmixer.h:99
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
WCHAR szName[MIXER_LONG_NAME_CHARS]
Definition: mmsystem.h:1310
DWORD cControls
Definition: mmsystem.h:1264
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
_In_ WDFCOLLECTION _In_ ULONG Index

Referenced by WdmAudGetLineControls().

◆ MMixerGetLineInfo()

MIXER_STATUS MMixerGetLineInfo ( IN PMIXER_CONTEXT  MixerContext,
IN HANDLE  MixerHandle,
IN ULONG  MixerId,
IN ULONG  Flags,
OUT LPMIXERLINEW  MixerLine 
)

Definition at line 148 of file mixer.c.

154{
156 LPMIXER_INFO MixerInfo;
157 LPMIXERLINE_EXT MixerLineSrc;
158 ULONG DestinationLineID;
159
160 /* verify mixer context */
162
164 {
165 /* invalid context passed */
166 return Status;
167 }
169 {
170 /* caller passed mixer id */
171 MixerHandle = (HANDLE)MMixerGetMixerInfoByIndex(MixerContext, MixerId);
172
173 if (!MixerHandle)
174 {
175 /* invalid parameter */
177 }
178 }
179
180 if (MixerLine->cbStruct != sizeof(MIXERLINEW))
181 {
182 DPRINT1("MixerLine Expected %lu but got %lu\n", sizeof(MIXERLINEW), MixerLine->cbStruct);
184 }
185
186 /* clear hmixer from flags */
187 Flags &=~MIXER_OBJECTF_HMIXER;
188
189 DPRINT("MMixerGetLineInfo MixerId %lu Flags %lu\n", MixerId, Flags);
190
192 {
193 /* cast to mixer info */
194 MixerInfo = (LPMIXER_INFO)MixerHandle;
195
196 /* calculate destination line id */
197 DestinationLineID = (MixerLine->dwDestination + DESTINATION_LINE);
198
199 /* get destination line */
200 MixerLineSrc = MMixerGetSourceMixerLineByLineId(MixerInfo, DestinationLineID);
201
202 if (MixerLineSrc == NULL)
203 {
204 DPRINT1("MixerCaps Name %S DestinationLineCount %lu dwDestination %lu not found\n", MixerInfo->MixCaps.szPname, MixerInfo->MixCaps.cDestinations, MixerLine->dwDestination);
206 }
207 /* copy mixer line */
208 MixerContext->Copy(MixerLine, &MixerLineSrc->Line, sizeof(MIXERLINEW));
209
210 /* make sure it is null terminated */
211 MixerLine->szName[MIXER_LONG_NAME_CHARS-1] = L'\0';
212 MixerLine->szShortName[MIXER_SHORT_NAME_CHARS-1] = L'\0';
213 MixerLine->Target.szPname[MAXPNAMELEN-1] = L'\0';
214
215 /* done */
216 return MM_STATUS_SUCCESS;
217 }
219 {
220 /* cast to mixer info */
221 MixerInfo = (LPMIXER_INFO)MixerHandle;
222
223 /* calculate destination line id */
224 DestinationLineID = (MixerLine->dwDestination + DESTINATION_LINE);
225
226 /* get destination line */
227 MixerLineSrc = MMixerGetSourceMixerLineByLineId(MixerInfo, DestinationLineID);
228
229 if (MixerLineSrc == NULL)
230 {
231 DPRINT1("MixerCaps Name %S DestinationLineCount %lu dwDestination %lu not found\n", MixerInfo->MixCaps.szPname, MixerInfo->MixCaps.cDestinations, MixerLine->dwDestination);
233 }
234
235 /* check if dwSource is out of bounds */
236 if (MixerLine->dwSource >= MixerLineSrc->Line.cConnections)
237 {
238 DPRINT1("MixerCaps Name %S MixerLineName %S Connections %lu dwSource %lu not found\n", MixerInfo->MixCaps.szPname, MixerLineSrc->Line.szName, MixerLineSrc->Line.cConnections, MixerLine->dwSource);
240 }
241
242 /* calculate destination line id */
243 DestinationLineID = (MixerLine->dwSource * SOURCE_LINE) + MixerLine->dwDestination;
244
245 DPRINT("MixerName %S cDestinations %lu MixerLineName %S cConnections %lu dwSource %lu dwDestination %lu ID %lx\n", MixerInfo->MixCaps.szPname, MixerInfo->MixCaps.cDestinations,
246 MixerLineSrc->Line.szName, MixerLineSrc->Line.cConnections,
247 MixerLine->dwSource, MixerLine->dwDestination,
248 DestinationLineID);
249 /* get target destination line id */
250 MixerLineSrc = MMixerGetSourceMixerLineByLineId(MixerInfo, DestinationLineID);
251
252 /* sanity check */
253 ASSERT(MixerLineSrc);
254
255 DPRINT("Line %u Name %S\n", MixerLineSrc->Line.dwSource, MixerLineSrc->Line.szName);
256
257 /* copy mixer line */
258 MixerContext->Copy(MixerLine, &MixerLineSrc->Line, sizeof(MIXERLINEW));
259
260 /* make sure it is null terminated */
261 MixerLine->szName[MIXER_LONG_NAME_CHARS-1] = L'\0';
262 MixerLine->szShortName[MIXER_SHORT_NAME_CHARS-1] = L'\0';
263 MixerLine->Target.szPname[MAXPNAMELEN-1] = L'\0';
264
265 /* done */
266 return MM_STATUS_SUCCESS;
267 }
269 {
270 /* cast to mixer info */
271 MixerInfo = (LPMIXER_INFO)MixerHandle;
272
273 /* try to find line */
274 MixerLineSrc = MMixerGetSourceMixerLineByLineId(MixerInfo, MixerLine->dwLineID);
275 if (!MixerLineSrc)
276 {
277 /* invalid parameter */
278 DPRINT1("MMixerGetLineInfo: MixerName %S Line not found 0x%lx\n", MixerInfo->MixCaps.szPname, MixerLine->dwLineID);
280 }
281
282 DPRINT("Line %u Name %S\n", MixerLineSrc->Line.dwSource, MixerLineSrc->Line.szName);
283
284 /* copy mixer line*/
285 MixerContext->Copy(MixerLine, &MixerLineSrc->Line, sizeof(MIXERLINEW));
286
287 /* make sure it is null terminated */
288 MixerLine->szName[MIXER_LONG_NAME_CHARS-1] = L'\0';
289 MixerLine->szShortName[MIXER_SHORT_NAME_CHARS-1] = L'\0';
290 MixerLine->Target.szPname[MAXPNAMELEN-1] = L'\0';
291
292 return MM_STATUS_SUCCESS;
293 }
295 {
296 /* cast to mixer info */
297 MixerInfo = (LPMIXER_INFO)MixerHandle;
298
299 /* find mixer line by component type */
300 MixerLineSrc = MMixerGetSourceMixerLineByComponentType(MixerInfo, MixerLine->dwComponentType);
301 if (!MixerLineSrc)
302 {
303 DPRINT1("Failed to find component type %x\n", MixerLine->dwComponentType);
305 }
306
307 /* copy mixer line */
308 MixerContext->Copy(MixerLine, &MixerLineSrc->Line, sizeof(MIXERLINEW));
309
310 /* make sure it is null terminated */
311 MixerLine->szName[MIXER_LONG_NAME_CHARS-1] = L'\0';
312 MixerLine->szShortName[MIXER_SHORT_NAME_CHARS-1] = L'\0';
313 MixerLine->Target.szPname[MAXPNAMELEN-1] = L'\0';
314
315 /* done */
316 return MM_STATUS_SUCCESS;
317 }
319 {
320 DPRINT1("MIXER_GETLINEINFOF_TARGETTYPE handling is unimplemented\n");
321 }
322 else
323 {
324 DPRINT1("Unknown Flags %lx handling is unimplemented\n", Flags);
325 }
326
328}
#define MIXER_GETLINEINFOF_LINEID
Definition: mmsystem.h:346
#define MIXER_GETLINEINFOF_TARGETTYPE
Definition: mmsystem.h:348
#define MIXER_GETLINEINFOF_DESTINATION
Definition: mmsystem.h:344
#define MIXER_GETLINEINFOF_COMPONENTTYPE
Definition: mmsystem.h:347
#define MIXER_GETLINEINFOF_SOURCE
Definition: mmsystem.h:345
LPMIXERLINE_EXT MMixerGetSourceMixerLineByComponentType(LPMIXER_INFO MixerInfo, DWORD dwComponentType)
Definition: sup.c:255
#define DESTINATION_LINE
Definition: precomp.h:176
#define SOURCE_LINE
Definition: precomp.h:177
DWORD dwSource
Definition: mmsystem.h:1257
WCHAR szName[MIXER_LONG_NAME_CHARS]
Definition: mmsystem.h:1266
DWORD cConnections
Definition: mmsystem.h:1263

Referenced by WdmAudGetLineInfo().

◆ MMixerGetMidiDevicePath()

MIXER_STATUS MMixerGetMidiDevicePath ( IN PMIXER_CONTEXT  MixerContext,
IN ULONG  bMidiIn,
IN ULONG  DeviceId,
OUT LPWSTR DevicePath 
)

Definition at line 380 of file midi.c.

385{
386 PMIXER_LIST MixerList;
387 LPMIXER_DATA MixerData;
388 LPMIDI_INFO MidiInfo;
391
392 /* verify mixer context */
394
396 {
397 /* invalid context passed */
398 return Status;
399 }
400
401 /* grab mixer list */
403
404 /* find destination midi */
405 Status = MMixerGetMidiInfoByIndexAndType(MixerList, DeviceId, bMidiIn, &MidiInfo);
407 {
408 /* failed to find midi info */
410 }
411
412 /* get associated device id */
413 MixerData = MMixerGetDataByDeviceId(MixerList, MidiInfo->DeviceId);
414 if (!MixerData)
416
417 /* calculate length */
418 Length = wcslen(MixerData->DeviceName)+1;
419
420 /* allocate destination buffer */
421 *DevicePath = MixerContext->Alloc(Length * sizeof(WCHAR));
422
423 if (!*DevicePath)
424 {
425 /* no memory */
426 return MM_STATUS_NO_MEMORY;
427 }
428
429 /* copy device path */
430 MixerContext->Copy(*DevicePath, MixerData->DeviceName, Length * sizeof(WCHAR));
431
432 /* done */
433 return MM_STATUS_SUCCESS;
434}
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
MIXER_STATUS MMixerGetMidiInfoByIndexAndType(IN PMIXER_LIST MixerList, IN ULONG DeviceIndex, IN ULONG bMidiInputType, OUT LPMIDI_INFO *OutMidiInfo)
Definition: midi.c:273
LPMIXER_DATA MMixerGetDataByDeviceId(IN PMIXER_LIST MixerList, IN ULONG DeviceId)
Definition: sup.c:735
ULONG DeviceId
Definition: precomp.h:137
PMIXER_ALLOC Alloc
Definition: mmixer.h:94
LPWSTR DeviceName
Definition: precomp.h:117
ULONG_PTR SIZE_T
Definition: typedefs.h:80
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by WdmAudGetPnpNameByIndexAndType().

◆ MMixerGetMidiInCount()

ULONG MMixerGetMidiInCount ( IN PMIXER_CONTEXT  MixerContext)

Definition at line 502 of file midi.c.

504{
505 PMIXER_LIST MixerList;
507
508 /* verify mixer context */
510
512 {
513 /* invalid context passed */
514 return Status;
515 }
516
517 /* grab mixer list */
519
520 return MixerList->MidiInListCount;
521}
ULONG MidiInListCount
Definition: precomp.h:161

Referenced by WdmAudGetMidiInDeviceCount().

◆ MMixerGetMidiOutCount()

ULONG MMixerGetMidiOutCount ( IN PMIXER_CONTEXT  MixerContext)

Definition at line 524 of file midi.c.

526{
527 PMIXER_LIST MixerList;
529
530 /* verify mixer context */
532
534 {
535 /* invalid context passed */
536 return Status;
537 }
538
539 /* grab mixer list */
541
542 return MixerList->MidiOutListCount;
543}
ULONG MidiOutListCount
Definition: precomp.h:164

◆ MMixerGetWaveDevicePath()

MIXER_STATUS MMixerGetWaveDevicePath ( IN PMIXER_CONTEXT  MixerContext,
IN ULONG  bWaveIn,
IN ULONG  DeviceId,
OUT LPWSTR DevicePath 
)

Definition at line 670 of file wave.c.

675{
676 PMIXER_LIST MixerList;
677 LPMIXER_DATA MixerData;
678 LPWAVE_INFO WaveInfo;
681
682 /* verify mixer context */
684
686 {
687 /* invalid context passed */
688 return Status;
689 }
690
691 /* grab mixer list */
693
694 /* find destination wave */
695 Status = MMixerGetWaveInfoByIndexAndType(MixerList, DeviceId, bWaveIn, &WaveInfo);
697 {
698 /* failed to find wave info */
700 }
701
702 /* get associated device id */
703 MixerData = MMixerGetDataByDeviceId(MixerList, WaveInfo->DeviceId);
704 if (!MixerData)
706
707 /* calculate length */
708 Length = wcslen(MixerData->DeviceName)+1;
709
710 /* allocate destination buffer */
711 *DevicePath = MixerContext->Alloc(Length * sizeof(WCHAR));
712
713 if (!*DevicePath)
714 {
715 /* no memory */
716 return MM_STATUS_NO_MEMORY;
717 }
718
719 /* copy device path */
720 MixerContext->Copy(*DevicePath, MixerData->DeviceName, Length * sizeof(WCHAR));
721
722 /* done */
723 return MM_STATUS_SUCCESS;
724}
MIXER_STATUS MMixerGetWaveInfoByIndexAndType(IN PMIXER_LIST MixerList, IN ULONG DeviceIndex, IN ULONG bWaveInType, OUT LPWAVE_INFO *OutWaveInfo)
Definition: wave.c:80
ULONG DeviceId
Definition: precomp.h:125

Referenced by WdmAudGetPnpNameByIndexAndType().

◆ MMixerGetWaveInCount()

ULONG MMixerGetWaveInCount ( IN PMIXER_CONTEXT  MixerContext)

Definition at line 574 of file wave.c.

576{
577 PMIXER_LIST MixerList;
579
580 /* verify mixer context */
582
584 {
585 /* invalid context passed */
586 return Status;
587 }
588
589 /* grab mixer list */
591
592 return MixerList->WaveInListCount;
593}
ULONG WaveInListCount
Definition: precomp.h:155

Referenced by WdmAudGetNumWdmDevsByMMixer(), and WdmAudGetWaveInDeviceCount().

◆ MMixerGetWaveOutCount()

ULONG MMixerGetWaveOutCount ( IN PMIXER_CONTEXT  MixerContext)

Definition at line 596 of file wave.c.

598{
599 PMIXER_LIST MixerList;
601
602 /* verify mixer context */
604
606 {
607 /* invalid context passed */
608 return Status;
609 }
610
611 /* grab mixer list */
613
614 return MixerList->WaveOutListCount;
615}
ULONG WaveOutListCount
Definition: precomp.h:158

Referenced by WdmAudGetMidiOutDeviceCount(), WdmAudGetNumWdmDevsByMMixer(), and WdmAudGetWaveOutDeviceCount().

◆ MMixerInitialize()

MIXER_STATUS MMixerInitialize ( IN PMIXER_CONTEXT  MixerContext,
IN PMIXER_ENUM  EnumFunction,
IN PVOID  EnumContext 
)

Definition at line 768 of file mixer.c.

772{
775 ULONG DeviceIndex, Count;
777 LPMIXER_DATA MixerData;
778 PMIXER_LIST MixerList;
780
781 if (!MixerContext || !EnumFunction || !EnumContext)
782 {
783 /* invalid parameter */
785 }
786
790 {
791 /* invalid parameter */
793 }
794
795 /* allocate a mixer list */
796 MixerList = (PMIXER_LIST)MixerContext->Alloc(sizeof(MIXER_LIST));
797 if (!MixerList)
798 {
799 /* no memory */
800 return MM_STATUS_NO_MEMORY;
801 }
802
803 /* initialize mixer list */
804 MixerList->MixerListCount = 0;
805 MixerList->MixerDataCount = 0;
806 MixerList->WaveInListCount = 0;
807 MixerList->WaveOutListCount = 0;
808 MixerList->MidiInListCount = 0;
809 MixerList->MidiOutListCount = 0;
810 InitializeListHead(&MixerList->MixerList);
811 InitializeListHead(&MixerList->MixerData);
812 InitializeListHead(&MixerList->WaveInList);
813 InitializeListHead(&MixerList->WaveOutList);
814 InitializeListHead(&MixerList->MidiInList);
815 InitializeListHead(&MixerList->MidiOutList);
816
817 /* store mixer list */
818 MixerContext->MixerContext = (PVOID)MixerList;
819
820 /* start enumerating all available devices */
821 Count = 0;
822 DeviceIndex = 0;
823
824 do
825 {
826 /* enumerate a device */
827 Status = EnumFunction(EnumContext, DeviceIndex, &DeviceName, &hMixer, &hKey);
828
830 {
831 /* check error code */
833 {
834 /* enumeration has finished */
835 break;
836 }
837 else
838 {
839 DPRINT1("Failed to enumerate device %lu\n", DeviceIndex);
840
841 /* TODO cleanup */
842 return Status;
843 }
844 }
845 else
846 {
847 /* create a mixer data entry */
848 Status = MMixerCreateMixerData(MixerContext, MixerList, DeviceIndex, DeviceName, hMixer, hKey);
850 break;
851 }
852
853 /* increment device index */
854 DeviceIndex++;
855 }while(TRUE);
856
857 /* now all filters have been pre-opened
858 * lets enumerate the filters
859 */
860 Entry = MixerList->MixerData.Flink;
861 while(Entry != &MixerList->MixerData)
862 {
864 MMixerSetupFilter(MixerContext, MixerList, MixerData, &Count);
865 Entry = Entry->Flink;
866 }
867
868 Entry = MixerList->MixerData.Flink;
869 while(Entry != &MixerList->MixerData)
870 {
872
873 /* now handle alternative mixer types */
874 MMixerHandleAlternativeMixers(MixerContext, MixerList, MixerData, MixerData->Topology);
875 Entry = Entry->Flink;
876 }
877
878 //MMixerPrintMixers(MixerContext, MixerList);
879
880 /* done */
881 return MM_STATUS_SUCCESS;
882}
VOID MMixerHandleAlternativeMixers(IN PMIXER_CONTEXT MixerContext, IN PMIXER_LIST MixerList, IN LPMIXER_DATA MixerData, IN PTOPOLOGY Topology)
Definition: controls.c:1676
MIXER_STATUS MMixerSetupFilter(IN PMIXER_CONTEXT MixerContext, IN PMIXER_LIST MixerList, IN LPMIXER_DATA MixerData, IN PULONG DeviceCount)
Definition: controls.c:1749
#define TRUE
Definition: types.h:120
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
FxAutoRegKey hKey
HMIXER hMixer
Definition: test.c:10
int Count
Definition: noreturn.cpp:7
struct MIXER_DATA * LPMIXER_DATA
MIXER_STATUS MMixerCreateMixerData(IN PMIXER_CONTEXT MixerContext, IN PMIXER_LIST MixerList, IN ULONG DeviceId, IN LPWSTR DeviceName, IN HANDLE hDevice, IN HANDLE hKey)
Definition: sup.c:778
PMIXER_ALLOC_EVENT_DATA AllocEventData
Definition: mmixer.h:103
PMIXER_OPEN_KEY OpenKey
Definition: mmixer.h:100
PMIXER_DEVICE_CONTROL Control
Definition: mmixer.h:95
PMIXER_CLOSE Close
Definition: mmixer.h:98
PMIXER_CLOSEKEY CloseKey
Definition: mmixer.h:102
PMIXER_QUERY_KEY_VALUE QueryKeyValue
Definition: mmixer.h:101
PMIXER_FREE_EVENT_DATA FreeEventData
Definition: mmixer.h:104
PMIXER_OPEN Open
Definition: mmixer.h:97
PMIXER_FREE Free
Definition: mmixer.h:96
PTOPOLOGY Topology
Definition: precomp.h:118
ULONG MixerDataCount
Definition: precomp.h:152
LIST_ENTRY MidiOutList
Definition: precomp.h:165
LIST_ENTRY MidiInList
Definition: precomp.h:162
LIST_ENTRY WaveInList
Definition: precomp.h:156
LIST_ENTRY MixerData
Definition: precomp.h:153
LIST_ENTRY WaveOutList
Definition: precomp.h:159
LIST_ENTRY MixerList
Definition: precomp.h:150
void * PVOID
Definition: typedefs.h:50
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3275
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by WdmAudInitUserModeMixer(), and WdmAudMixerInitialize().

◆ MMixerMidiInCapabilities()

MIXER_STATUS MMixerMidiInCapabilities ( IN PMIXER_CONTEXT  MixerContext,
IN ULONG  DeviceIndex,
OUT LPMIDIINCAPSW  Caps 
)

Definition at line 344 of file midi.c.

348{
349 PMIXER_LIST MixerList;
351 LPMIDI_INFO MidiInfo;
352
353 /* verify mixer context */
355
357 {
358 /* invalid context passed */
359 return Status;
360 }
361
362 /* grab mixer list */
364
365 /* find destination midi */
366 Status = MMixerGetMidiInfoByIndexAndType(MixerList, DeviceIndex, TRUE, &MidiInfo);
368 {
369 /* failed to find midi info */
371 }
372
373 /* copy capabilities */
374 MixerContext->Copy(Caps, &MidiInfo->u.InCaps, sizeof(MIDIINCAPSW));
375
376 return MM_STATUS_SUCCESS;
377}
union MIDI_INFO::@4336 u
MIDIINCAPSW InCaps
Definition: precomp.h:142

Referenced by WdmAudMidiCapabilities().

◆ MMixerMidiOutCapabilities()

MIXER_STATUS MMixerMidiOutCapabilities ( IN PMIXER_CONTEXT  MixerContext,
IN ULONG  DeviceIndex,
OUT LPMIDIOUTCAPSW  Caps 
)

Definition at line 308 of file midi.c.

312{
313 PMIXER_LIST MixerList;
315 LPMIDI_INFO MidiInfo;
316
317 /* verify mixer context */
319
321 {
322 /* invalid context passed */
323 return Status;
324 }
325
326 /* grab mixer list */
328
329 /* find destination midi */
330 Status = MMixerGetMidiInfoByIndexAndType(MixerList, DeviceIndex, FALSE, &MidiInfo);
332 {
333 /* failed to find midi info */
335 }
336
337 /* copy capabilities */
338 MixerContext->Copy(Caps, &MidiInfo->u.OutCaps, sizeof(MIDIOUTCAPSW));
339
340 return MM_STATUS_SUCCESS;
341}
MIDIOUTCAPSW OutCaps
Definition: precomp.h:141

Referenced by WdmAudMidiCapabilities().

◆ MMixerOpen()

MIXER_STATUS MMixerOpen ( IN PMIXER_CONTEXT  MixerContext,
IN ULONG  MixerId,
IN PVOID  MixerEventContext,
IN PMIXER_EVENT  MixerEventRoutine,
OUT PHANDLE  MixerHandle 
)

Definition at line 77 of file mixer.c.

83{
85 LPMIXER_INFO MixerInfo;
86
87 /* verify mixer context */
89
91 {
92 /* invalid context passed */
93 DPRINT1("invalid context\n");
94 return Status;
95 }
96
97 /* get mixer info */
99 if (!MixerInfo)
100 {
101 /* invalid mixer id */
102 DPRINT1("invalid mixer id %lu\n", MixerId);
104 }
105
106 /* add the event */
107 Status = MMixerAddEvent(MixerContext, MixerInfo, MixerEventContext, MixerEventRoutine);
108
109 /* store result */
110 *MixerHandle = (HANDLE)MixerInfo;
111 return MM_STATUS_SUCCESS;
112}
MIXER_STATUS MMixerAddEvent(IN PMIXER_CONTEXT MixerContext, IN OUT LPMIXER_INFO MixerInfo, IN PVOID MixerEventContext, IN PMIXER_EVENT MixerEventRoutine)
Definition: controls.c:1827

Referenced by WdmAudControlOpenMixer(), and WdmAudSetMixerDeviceFormatByMMixer().

◆ MMixerOpenMidi()

MIXER_STATUS MMixerOpenMidi ( IN PMIXER_CONTEXT  MixerContext,
IN ULONG  DeviceIndex,
IN ULONG  bMidiIn,
IN PIN_CREATE_CALLBACK  CreateCallback,
IN PVOID  Context,
OUT PHANDLE  PinHandle 
)

Definition at line 454 of file midi.c.

461{
462 PMIXER_LIST MixerList;
464 LPMIDI_INFO MidiInfo;
466
467 /* verify mixer context */
469
471 {
472 /* invalid context passed */
473 return Status;
474 }
475
476 /* grab mixer list */
478
479 /* find destination midi */
480 Status = MMixerGetMidiInfoByIndexAndType(MixerList, DeviceIndex, bMidiIn, &MidiInfo);
482 {
483 /* failed to find midi info */
485 }
486
487 /* get desired access */
488 if (bMidiIn)
489 {
491 }
492 else
493 {
495 }
496
497 /* now try open the pin */
498 return MMixerOpenMidiPin(MixerContext, MixerList, MidiInfo->DeviceId, MidiInfo->PinId, DesiredAccess, CreateCallback, Context, PinHandle);
499}
#define GENERIC_READ
Definition: compat.h:135
ULONG ACCESS_MASK
Definition: nt_native.h:40
#define GENERIC_WRITE
Definition: nt_native.h:90
MIXER_STATUS MMixerOpenMidiPin(IN PMIXER_CONTEXT MixerContext, IN PMIXER_LIST MixerList, IN ULONG DeviceId, IN ULONG PinId, IN ACCESS_MASK DesiredAccess, IN PIN_CREATE_CALLBACK CreateCallback, IN PVOID Context, OUT PHANDLE PinHandle)
Definition: midi.c:209
ULONG PinId
Definition: precomp.h:138
_Must_inspect_result_ _In_ WDFDEVICE _In_ ULONG _In_ ACCESS_MASK DesiredAccess
Definition: wdfdevice.h:2658

Referenced by WdmAudControlOpenMidi().

◆ MMixerOpenWave()

MIXER_STATUS MMixerOpenWave ( IN PMIXER_CONTEXT  MixerContext,
IN ULONG  DeviceIndex,
IN ULONG  bWaveIn,
IN LPWAVEFORMATEX  WaveFormat,
IN PIN_CREATE_CALLBACK  CreateCallback,
IN PVOID  Context,
OUT PHANDLE  PinHandle 
)

Definition at line 453 of file wave.c.

461{
462 PMIXER_LIST MixerList;
464 LPWAVE_INFO WaveInfo;
466
467 /* verify mixer context */
469
471 {
472 /* invalid context passed */
473 return Status;
474 }
475
476 /* grab mixer list */
478
479 /* find destination wave */
480 Status = MMixerGetWaveInfoByIndexAndType(MixerList, DeviceIndex, bWaveIn, &WaveInfo);
482 {
483 /* failed to find wave info */
485 }
486
487 /* get desired access */
488 if (bWaveIn)
489 {
491 }
492 else
493 {
495 }
496
497 /* now try open the pin */
498 return MMixerOpenWavePin(MixerContext, MixerList, WaveInfo->DeviceId, WaveInfo->PinId, WaveFormat, DesiredAccess, CreateCallback, Context, PinHandle);
499}
MIXER_STATUS MMixerOpenWavePin(IN PMIXER_CONTEXT MixerContext, IN PMIXER_LIST MixerList, IN ULONG DeviceId, IN ULONG PinId, IN LPWAVEFORMATEX WaveFormatEx, IN ACCESS_MASK DesiredAccess, IN PIN_CREATE_CALLBACK CreateCallback, IN PVOID Context, OUT PHANDLE PinHandle)
Definition: wave.c:232
ULONG PinId
Definition: precomp.h:126

Referenced by WdmAudControlOpenWave(), and WdmAudSetWaveDeviceFormatByMMixer().

◆ MMixerSetControlDetails()

MIXER_STATUS MMixerSetControlDetails ( IN PMIXER_CONTEXT  MixerContext,
IN HANDLE  MixerHandle,
IN ULONG  MixerId,
IN ULONG  Flags,
OUT LPMIXERCONTROLDETAILS  MixerControlDetails 
)

Definition at line 495 of file mixer.c.

501{
503 ULONG NodeId;
504 LPMIXER_INFO MixerInfo;
505 LPMIXERLINE_EXT MixerLine;
506 LPMIXERCONTROL_EXT MixerControl;
507
508 /* verify mixer context */
510
512 {
513 /* invalid context passed */
514 DPRINT1("invalid context\n");
515 return Status;
516 }
517
519 {
520 /* caller passed mixer id */
521 MixerHandle = (HANDLE)MMixerGetMixerInfoByIndex(MixerContext, MixerId);
522
523 if (!MixerHandle)
524 {
525 /* invalid parameter */
526 DPRINT1("invalid handle\n");
528 }
529 }
530
531 /* get mixer info */
532 MixerInfo = (LPMIXER_INFO)MixerHandle;
533
534 /* get mixer control */
535 Status = MMixerGetMixerControlById(MixerInfo, MixerControlDetails->dwControlID, &MixerLine, &MixerControl, &NodeId);
536
537 /* check for success */
539 {
540 /* failed to find control id */
541 DPRINT1("invalid control id %lu\n", MixerControlDetails->dwControlID);
543 }
544
545 DPRINT("MMixerSetControlDetails ControlType %lx MixerControlName %S MixerLineName %S NodeID %lu\n", MixerControl->Control.dwControlType, MixerControl->Control.szName, MixerLine->Line.szName, NodeId);
546 switch(MixerControl->Control.dwControlType)
547 {
549 Status = MMixerSetGetMuteControlDetails(MixerContext, MixerInfo, MixerControl, MixerLine->Line.dwLineID, MixerControlDetails, TRUE);
550 break;
552 Status = MMixerSetGetVolumeControlDetails(MixerContext, MixerInfo, NodeId, TRUE, MixerControl, MixerControlDetails, MixerLine);
553 break;
555 Status = MMixerSetGetMuxControlDetails(MixerContext, MixerInfo, NodeId, TRUE, Flags, MixerControl, MixerControlDetails, MixerLine);
556 break;
557 default:
559 }
560
561 return Status;
562}

Referenced by WdmAudSetControlDetails().

◆ MMixerSetMidiStatus()

MIXER_STATUS MMixerSetMidiStatus ( IN PMIXER_CONTEXT  MixerContext,
IN HANDLE  PinHandle,
IN KSSTATE  State 
)

Definition at line 437 of file midi.c.

441{
444
445 /* setup property request */
449
450 return MixerContext->Control(PinHandle, IOCTL_KS_PROPERTY, &Property, sizeof(KSPROPERTY), &State, sizeof(KSSTATE), &Length);
451}
#define KSPROPERTY_TYPE_SET
Definition: dmksctrl.h:43
@ KSPROPERTY_CONNECTION_STATE
Definition: ks.h:349
#define IOCTL_KS_PROPERTY
Definition: ks.h:127
KSSTATE
Definition: ks.h:1214
#define KSPROPSETID_Connection
Definition: ks.h:346

Referenced by WdmAudSetWaveStateByMMixer().

◆ MMixerSetWaveResetState()

MIXER_STATUS MMixerSetWaveResetState ( IN PMIXER_CONTEXT  MixerContext,
IN HANDLE  PinHandle,
IN ULONG  bBegin 
)

Definition at line 645 of file wave.c.

649{
652 KSRESET Reset;
653
654 /* verify mixer context */
656
658 {
659 /* invalid context passed */
660 return Status;
661 }
662
663 /* begin / stop reset */
664 Reset = (bBegin ? KSRESET_BEGIN : KSRESET_END);
665
666 return MixerContext->Control(PinHandle, IOCTL_KS_RESET_STATE, &Reset, sizeof(KSRESET), NULL, 0, &Length);
667}
KSRESET
Definition: ks.h:1226
@ KSRESET_BEGIN
Definition: ks.h:1227
@ KSRESET_END
Definition: ks.h:1228
#define IOCTL_KS_RESET_STATE
Definition: ks.h:145

Referenced by WdmAudResetStreamByMMixer().

◆ MMixerSetWaveStatus()

MIXER_STATUS MMixerSetWaveStatus ( IN PMIXER_CONTEXT  MixerContext,
IN HANDLE  PinHandle,
IN KSSTATE  State 
)

Definition at line 618 of file wave.c.

622{
626
627 /* verify mixer context */
629
631 {
632 /* invalid context passed */
633 return Status;
634 }
635
636 /* setup property request */
640
641 return MixerContext->Control(PinHandle, IOCTL_KS_PROPERTY, &Property, sizeof(KSPROPERTY), &State, sizeof(KSSTATE), &Length);
642}
const GUID KSPROPSETID_Connection
Definition: wave.c:14

Referenced by WdmAudCloseSoundDeviceByMMixer(), WdmAudSetWaveDeviceFormatByMMixer(), and WdmAudSetWaveStateByMMixer().

◆ MMixerWaveInCapabilities()

MIXER_STATUS MMixerWaveInCapabilities ( IN PMIXER_CONTEXT  MixerContext,
IN ULONG  DeviceIndex,
OUT LPWAVEINCAPSW  Caps 
)

Definition at line 502 of file wave.c.

506{
507 PMIXER_LIST MixerList;
509 LPWAVE_INFO WaveInfo;
510
511 /* verify mixer context */
513
515 {
516 /* invalid context passed */
517 return Status;
518 }
519
520 /* grab mixer list */
522
523 /* find destination wave */
524 Status = MMixerGetWaveInfoByIndexAndType(MixerList, DeviceIndex, TRUE, &WaveInfo);
526 {
527 /* failed to find wave info */
529 }
530
531 /* copy capabilities */
532 MixerContext->Copy(Caps, &WaveInfo->u.InCaps, sizeof(WAVEINCAPSW));
533
534 return MM_STATUS_SUCCESS;
535}
union WAVE_INFO::@4335 u
WAVEINCAPSW InCaps
Definition: precomp.h:130

Referenced by WdmAudGetWaveInCapabilities(), and WdmAudWaveCapabilities().

◆ MMixerWaveOutCapabilities()

MIXER_STATUS MMixerWaveOutCapabilities ( IN PMIXER_CONTEXT  MixerContext,
IN ULONG  DeviceIndex,
OUT LPWAVEOUTCAPSW  Caps 
)

Definition at line 538 of file wave.c.

542{
543 PMIXER_LIST MixerList;
545 LPWAVE_INFO WaveInfo;
546
547 /* verify mixer context */
549
551 {
552 /* invalid context passed */
553 return Status;
554 }
555
556 /* grab mixer list */
558
559 /* find destination wave */
560 Status = MMixerGetWaveInfoByIndexAndType(MixerList, DeviceIndex, FALSE, &WaveInfo);
562 {
563 /* failed to find wave info */
565 }
566
567 /* copy capabilities */
568 MixerContext->Copy(Caps, &WaveInfo->u.OutCaps, sizeof(WAVEOUTCAPSW));
569
570 return MM_STATUS_SUCCESS;
571}
WAVEOUTCAPSW OutCaps
Definition: precomp.h:129

Referenced by WdmAudGetWaveOutCapabilities(), and WdmAudWaveCapabilities().