precomp.h File Reference

#include <wdm.h>
#include <windef.h>
#include <mmreg.h>
#include <ks.h>
#include <ksmedia.h>
#include <mmsystem.h>
#include "mmixer.h"

Include dependency graph for precomp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	__TOPOLOGY_NODE__
struct	PIN
struct	TOPOLOGY
struct	MIXER_INFO
struct	MIXERCONTROL_EXT
struct	MIXERLINE_EXT
struct	MIXERCONTROL_DATA
struct	MIXERVOLUME_DATA
struct	MIXER_DATA
struct	WAVE_INFO
struct	MIDI_INFO
struct	MIXER_LIST
struct	EVENT_NOTIFICATION_ENTRY

Macros
#define	NOBITMAP
#define	DESTINATION_LINE   (0xFFFF0000)
#define	SOURCE_LINE   (0x10000)

Typedefs
typedef struct __TOPOLOGY_NODE__	TOPOLOGY_NODE
typedef struct __TOPOLOGY_NODE__ *	PTOPOLOGY_NODE
typedef struct PIN *	PPIN
typedef struct TOPOLOGY *	PTOPOLOGY
typedef struct MIXER_INFO *	LPMIXER_INFO
typedef struct MIXERCONTROL_EXT *	LPMIXERCONTROL_EXT
typedef struct MIXERLINE_EXT *	LPMIXERLINE_EXT
typedef struct MIXERCONTROL_DATA *	LPMIXERCONTROL_DATA
typedef struct MIXERVOLUME_DATA *	LPMIXERVOLUME_DATA
typedef struct MIXER_DATA *	LPMIXER_DATA
typedef struct WAVE_INFO *	LPWAVE_INFO
typedef struct MIDI_INFO *	LPMIDI_INFO
typedef struct MIXER_LIST *	PMIXER_LIST
typedef struct EVENT_NOTIFICATION_ENTRY *	PEVENT_NOTIFICATION_ENTRY

Functions
ULONG	MMixerGetFilterPinCount (IN PMIXER_CONTEXT MixerContext, IN HANDLE hMixer)
LPGUID	MMixerGetNodeType (IN PKSMULTIPLE_ITEM MultipleItem, IN ULONG Index)
MIXER_STATUS	MMixerGetNodeIndexes (IN PMIXER_CONTEXT MixerContext, IN PKSMULTIPLE_ITEM MultipleItem, IN ULONG NodeIndex, IN ULONG bNode, IN ULONG bFrom, OUT PULONG NodeReferenceCount, OUT PULONG *NodeReference)
PKSTOPOLOGY_CONNECTION	MMixerGetConnectionByIndex (IN PKSMULTIPLE_ITEM MultipleItem, IN ULONG Index)
ULONG	MMixerGetControlTypeFromTopologyNode (IN LPGUID NodeType)
LPMIXERLINE_EXT	MMixerGetSourceMixerLineByLineId (LPMIXER_INFO MixerInfo, DWORD dwLineID)
MIXER_STATUS	MMixerGetFilterTopologyProperty (IN PMIXER_CONTEXT MixerContext, IN HANDLE hMixer, IN ULONG PropertyId, OUT PKSMULTIPLE_ITEM *OutMultipleItem)
VOID	MMixerFreeMixerInfo (IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo)
MIXER_STATUS	MMixerGetPhysicalConnection (IN PMIXER_CONTEXT MixerContext, IN HANDLE hMixer, IN ULONG PinId, OUT PKSPIN_PHYSICALCONNECTION *OutConnection)
MIXER_STATUS	MMixerSetupFilter (IN PMIXER_CONTEXT MixerContext, IN PMIXER_LIST MixerList, IN LPMIXER_DATA MixerData, IN PULONG DeviceCount)
PKSPIN_CONNECT	MMixerAllocatePinConnect (IN PMIXER_CONTEXT MixerContext, ULONG DataFormatSize)
MIXER_STATUS	MMixerGetAudioPinDataRanges (IN PMIXER_CONTEXT MixerContext, IN HANDLE hDevice, IN ULONG PinId, IN OUT PKSMULTIPLE_ITEM *OutMultipleItem)
VOID	MMixerInitializeMidiForFilter (IN PMIXER_CONTEXT MixerContext, IN PMIXER_LIST MixerList, IN LPMIXER_DATA MixerData, IN PTOPOLOGY Topology)
MIXER_STATUS	MMixerVerifyContext (IN PMIXER_CONTEXT MixerContext)
LPMIXER_INFO	MMixerGetMixerInfoByIndex (IN PMIXER_CONTEXT MixerContext, IN ULONG MixerIndex)
LPMIXERLINE_EXT	MMixerGetSourceMixerLineByComponentType (LPMIXER_INFO MixerInfo, DWORD dwComponentType)
MIXER_STATUS	MMixerGetMixerControlById (LPMIXER_INFO MixerInfo, DWORD dwControlID, LPMIXERLINE_EXT *MixerLine, LPMIXERCONTROL_EXT *MixerControl, PULONG NodeId)
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	MMixerSetGetVolumeControlDetails (IN PMIXER_CONTEXT MixerContext, IN LPMIXER_INFO MixerInfo, IN ULONG NodeId, IN ULONG bSet, LPMIXERCONTROL_EXT MixerControl, IN LPMIXERCONTROLDETAILS MixerControlDetails, LPMIXERLINE_EXT MixerLine)
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	MMixerSetGetControlDetails (IN PMIXER_CONTEXT MixerContext, IN HANDLE hMixer, IN ULONG NodeId, IN ULONG bSet, IN ULONG PropertyId, IN ULONG Channel, IN PLONG InputValue)
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	MMixerInitializeWaveInfo (IN PMIXER_CONTEXT MixerContext, IN PMIXER_LIST MixerList, IN LPMIXER_DATA MixerData, IN LPWSTR DeviceName, IN ULONG bWaveIn, IN ULONG PinCount, IN PULONG Pins)
MIXER_STATUS	MMixerAddEvent (IN PMIXER_CONTEXT MixerContext, IN OUT LPMIXER_INFO MixerInfo, IN PVOID MixerEvent, IN PMIXER_EVENT MixerEventRoutine)
MIXER_STATUS	MMixerRemoveEvent (IN PMIXER_CONTEXT MixerContext, IN OUT LPMIXER_INFO MixerInfo, IN PVOID MixerEventContext, IN PMIXER_EVENT MixerEventRoutine)
MIXER_STATUS	MMixerGetDeviceName (IN PMIXER_CONTEXT MixerContext, OUT LPWSTR DeviceName, IN HANDLE hKey)
MIXER_STATUS	MMixerGetDeviceNameWithComponentId (IN PMIXER_CONTEXT MixerContext, IN HANDLE hMixer, OUT LPWSTR DeviceName)
VOID	MMixerInitializePinConnect (IN OUT PKSPIN_CONNECT PinConnect, IN ULONG PinId)
MIXER_STATUS	MMixerGetPinDataFlowAndCommunication (IN PMIXER_CONTEXT MixerContext, IN HANDLE hDevice, IN ULONG PinId, OUT PKSPIN_DATAFLOW DataFlow, OUT PKSPIN_COMMUNICATION Communication)
VOID	MMixerHandleAlternativeMixers (IN PMIXER_CONTEXT MixerContext, IN PMIXER_LIST MixerList, IN LPMIXER_DATA MixerData, IN PTOPOLOGY Topology)
MIXER_STATUS	MMixerGetMixerByName (IN PMIXER_LIST MixerList, IN LPWSTR MixerName, OUT LPMIXER_INFO *MixerInfo)
MIXER_STATUS	MMixerCreateTopology (IN PMIXER_CONTEXT MixerContext, IN ULONG PinCount, IN PKSMULTIPLE_ITEM NodeConnections, IN PKSMULTIPLE_ITEM NodeTypes, OUT PTOPOLOGY *OutTopology)
VOID	MMixerGetAllUpOrDownstreamPinsFromNodeIndex (IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, IN ULONG NodeIndex, IN ULONG bUpStream, OUT PULONG OutPinsCount, OUT PULONG OutPins)
MIXER_STATUS	MMixerGetAllUpOrDownstreamPinsFromPinIndex (IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, IN ULONG PinIndex, IN ULONG bUpStream, OUT PULONG OutPinsCount, OUT PULONG OutPins)
VOID	MMixerGetNextNodesFromPinIndex (IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, IN ULONG PinIndex, IN ULONG bUpStream, OUT PULONG OutNodesCount, OUT PULONG OutNodes)
MIXER_STATUS	MMixerAllocateTopologyPinArray (IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, OUT PULONG *OutPins)
MIXER_STATUS	MMixerAllocateTopologyNodeArray (IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, OUT PULONG *OutPins)
VOID	MMixerGetAllUpOrDownstreamNodesFromPinIndex (IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, IN ULONG PinIndex, IN ULONG bUpStream, OUT PULONG OutNodesCount, OUT PULONG OutNodes)
VOID	MMixerIsNodeTerminator (IN PTOPOLOGY Topology, IN ULONG NodeIndex, OUT ULONG *bTerminator)
VOID	MMixerGetNextNodesFromNodeIndex (IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, IN ULONG NodeIndex, IN ULONG bUpStream, OUT PULONG OutNodesCount, OUT PULONG OutNodes)
LPGUID	MMixerGetNodeTypeFromTopology (IN PTOPOLOGY Topology, IN ULONG NodeIndex)
MIXER_STATUS	MMixerGetAllUpOrDownstreamNodesFromNodeIndex (IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, IN ULONG NodeIndex, IN ULONG bUpStream, OUT PULONG OutNodesCount, OUT PULONG OutNodes)
MIXER_STATUS	MMixerIsNodeConnectedToPin (IN PMIXER_CONTEXT MixerContext, IN PTOPOLOGY Topology, IN ULONG NodeIndex, IN ULONG PinId, IN ULONG bUpStream, OUT PULONG bConnected)
ULONG	MMixerGetNodeIndexFromGuid (IN PTOPOLOGY Topology, IN const GUID *NodeType)
VOID	MMixerSetTopologyNodeReserved (IN PTOPOLOGY Topology, IN ULONG NodeIndex)
VOID	MMixerIsTopologyNodeReserved (IN PTOPOLOGY Topology, IN ULONG NodeIndex, OUT PULONG bReserved)
VOID	MMixerSetTopologyPinReserved (IN PTOPOLOGY Topology, IN ULONG PinId)
VOID	MMixerIsTopologyPinReserved (IN PTOPOLOGY Topology, IN ULONG PinId, OUT PULONG bReserved)
VOID	MMixerGetTopologyPinCount (IN PTOPOLOGY Topology, OUT PULONG PinCount)
VOID	MMixerGetConnectedFromLogicalTopologyPins (IN PTOPOLOGY Topology, IN ULONG NodeIndex, OUT PULONG OutPinCount, OUT PULONG OutPins)
VOID	MMixerPrintTopology ()

Macro Definition Documentation

DESTINATION_LINE

#define DESTINATION_LINE   (0xFFFF0000)

Definition at line 176 of file precomp.h.

NOBITMAP

#define NOBITMAP

Definition at line 6 of file precomp.h.

SOURCE_LINE

#define SOURCE_LINE   (0x10000)

Definition at line 177 of file precomp.h.

Typedef Documentation

LPMIDI_INFO

typedef struct MIDI_INFO * LPMIDI_INFO

LPMIXER_DATA

typedef struct MIXER_DATA * LPMIXER_DATA

LPMIXER_INFO

typedef struct MIXER_INFO * LPMIXER_INFO

LPMIXERCONTROL_DATA

typedef struct MIXERCONTROL_DATA * LPMIXERCONTROL_DATA

LPMIXERCONTROL_EXT

typedef struct MIXERCONTROL_EXT * LPMIXERCONTROL_EXT

LPMIXERLINE_EXT

typedef struct MIXERLINE_EXT * LPMIXERLINE_EXT

LPMIXERVOLUME_DATA

typedef struct MIXERVOLUME_DATA * LPMIXERVOLUME_DATA

LPWAVE_INFO

typedef struct WAVE_INFO * LPWAVE_INFO

PEVENT_NOTIFICATION_ENTRY

typedef struct EVENT_NOTIFICATION_ENTRY * PEVENT_NOTIFICATION_ENTRY

PMIXER_LIST

typedef struct MIXER_LIST * PMIXER_LIST

PPIN

typedef struct PIN * PPIN

PTOPOLOGY

typedef struct TOPOLOGY * PTOPOLOGY

PTOPOLOGY_NODE

typedef struct __TOPOLOGY_NODE__ * PTOPOLOGY_NODE

TOPOLOGY_NODE

typedef struct __TOPOLOGY_NODE__ TOPOLOGY_NODE

Function Documentation

MMixerAddEvent()

MIXER_STATUS MMixerAddEvent	(	IN PMIXER_CONTEXT	MixerContext,
		IN OUT LPMIXER_INFO	MixerInfo,
		IN PVOID	MixerEvent,
		IN PMIXER_EVENT	MixerEventRoutine
	)

Definition at line 1834 of file controls.c.

{
    //KSE_NODE Property;
    //KSEVENTDATA EventData
    //ULONG BytesReturned;
    //MIXER_STATUS Status;
    PEVENT_NOTIFICATION_ENTRY EventNotification;
 
    EventNotification = (PEVENT_NOTIFICATION_ENTRY)MixerContext->Alloc(sizeof(EVENT_NOTIFICATION_ENTRY));
    if (!EventNotification)
    {
        /* not enough memory */
        return MM_STATUS_NO_MEMORY;
    }
 
    /* FIXME: what is it supposed to happen with KSEVENTDATA ? */
#if 0
    /* setup request */
    Property.Event.Set = KSEVENTSETID_AudioControlChange;
    Property.Event.Flags = KSEVENT_TYPE_TOPOLOGY|KSEVENT_TYPE_ENABLE;
    Property.Event.Id = KSEVENT_CONTROL_CHANGE;
 
    Property.NodeId = NodeId;
    Property.Reserved = 0;
 
    Status = MixerContext->Control(MixerInfo->hMixer, IOCTL_KS_ENABLE_EVENT, (PVOID)&Property, sizeof(KSP_NODE), (PVOID)EventData, sizeof(KSEVENTDATA), &BytesReturned);
    if (Status != MM_STATUS_SUCCESS)
    {
        /* failed to add event */
        MixerContext->FreeEventData(EventData);
        return Status;
    }
#endif
 
    /* initialize notification entry */
    EventNotification->MixerEventContext = MixerEventContext;
    EventNotification->MixerEventRoutine = MixerEventRoutine;
 
    /* store event */
    InsertTailList(&MixerInfo->EventList, &EventNotification->Entry);
    return MM_STATUS_SUCCESS;
}

Referenced by MMixerOpen().

MMixerAllocatePinConnect()

PKSPIN_CONNECT MMixerAllocatePinConnect	(	IN PMIXER_CONTEXT	MixerContext,
		ULONG	DataFormatSize
	)

Definition at line 72 of file wave.c.

{
    return MixerContext->Alloc(sizeof(KSPIN_CONNECT) + DataFormatSize);
}

Referenced by MMixerOpenMidiPin(), and MMixerOpenWavePin().

MMixerAllocateTopologyNodeArray()

MIXER_STATUS MMixerAllocateTopologyNodeArray	(	IN PMIXER_CONTEXT	MixerContext,
		IN PTOPOLOGY	Topology,
		OUT PULONG *	OutPins
	)

Definition at line 1052 of file topology.c.

{
    PULONG Nodes;
    ULONG Index;
 
    /* sanity check */
    ASSERT(Topology->TopologyNodesCount != 0);
 
    /* allocate topology pins */
    Nodes = MixerContext->Alloc(Topology->TopologyNodesCount * sizeof(ULONG));
 
    if (!Nodes)
    {
        /* out of memory */
        return MM_STATUS_NO_MEMORY;
    }
 
    /* mark index as unused */
    for(Index = 0; Index < Topology->TopologyNodesCount; Index++)
        Nodes[Index] = MAXULONG;
 
    /* store result */
    *OutNodes = Nodes;
 
    /* done */
    return MM_STATUS_SUCCESS;
}

Referenced by MMixerAddMixerControl(), MMixerAddMixerControlsToDestinationLine(), MMixerAddMixerSourceLines(), MMixerCountMixerControls(), and MMixerSetGetMuxControlDetails().

MMixerAllocateTopologyPinArray()

MIXER_STATUS MMixerAllocateTopologyPinArray	(	IN PMIXER_CONTEXT	MixerContext,
		IN PTOPOLOGY	Topology,
		OUT PULONG *	OutPins
	)

Definition at line 1020 of file topology.c.

{
    PULONG Pins;
    ULONG Index;
 
    /* sanity check */
    ASSERT(Topology->TopologyPinsCount != 0);
 
    /* allocate topology pins */
    Pins = MixerContext->Alloc(Topology->TopologyPinsCount * sizeof(ULONG));
 
    if (!Pins)
    {
        /* out of memory */
        return MM_STATUS_NO_MEMORY;
    }
 
    /* mark index as unused */
    for(Index = 0; Index < Topology->TopologyPinsCount; Index++)
        Pins[Index] = MAXULONG;
 
    /* store result */
    *OutPins = Pins;
 
    /* done */
    return MM_STATUS_SUCCESS;
}

Referenced by MMixerAddMixerSourceLines(), MMixerHandlePhysicalConnection(), MMixerHandleTopologyFilter(), MMixerInitializeFilter(), and MMixerIsNodeConnectedToPin().

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 781 of file sup.c.

{
    LPMIXER_DATA MixerData;
 
    MixerData = (LPMIXER_DATA)MixerContext->Alloc(sizeof(MIXER_DATA));
    if (!MixerData)
        return MM_STATUS_NO_MEMORY;
 
    MixerData->DeviceId = DeviceId;
    MixerData->DeviceName = DeviceName;
    MixerData->hDevice = hDevice;
    MixerData->hDeviceInterfaceKey = hKey;
    MixerData->Topology = NULL;
 
    InsertTailList(&MixerList->MixerData, &MixerData->Entry);
    MixerList->MixerDataCount++;
    return MM_STATUS_SUCCESS;
}

Referenced by MMixerInitialize().

MMixerCreateTopology()

MIXER_STATUS MMixerCreateTopology	(	IN PMIXER_CONTEXT	MixerContext,
		IN ULONG	PinCount,
		IN PKSMULTIPLE_ITEM	NodeConnections,
		IN PKSMULTIPLE_ITEM	NodeTypes,
		OUT PTOPOLOGY *	OutTopology
	)

Definition at line 1253 of file topology.c.

{
    MIXER_STATUS Status;
    PTOPOLOGY Topology;
 
    /* allocate topology */
    Status = MMixerAllocateTopology(MixerContext, NodeTypes->Count, PinCount, &Topology);
 
    if (Status != MM_STATUS_SUCCESS)
    {
        /* failed to allocate topology */
        return Status;
    }
 
    /* initialize topology nodes */
    MMixerInitializeTopologyNodes(MixerContext, NodeTypes, Topology);
 
    /* explore topology */
    Status = MMixerExploreTopology(MixerContext, NodeConnections, NodeTypes, Topology);
 
    if (Status != MM_STATUS_SUCCESS)
    {
        /* failed to allocate topology */
        return Status;
    }
 
    MMixerPrintTopology(Topology);
 
    /* store result */
    *OutTopology = Topology;
 
    /* done */
    return MM_STATUS_SUCCESS;
}

Referenced by MMixerBuildTopology().

MMixerFreeMixerInfo()

VOID MMixerFreeMixerInfo	(	IN PMIXER_CONTEXT	MixerContext,
		IN LPMIXER_INFO	MixerInfo
	)

Definition at line 116 of file sup.c.

{
    /* UNIMPLEMENTED;
     * FIXME
     * free all lines
     */
 
    MixerContext->Free((PVOID)MixerInfo);
}

MMixerGetAllUpOrDownstreamNodesFromNodeIndex()

MIXER_STATUS MMixerGetAllUpOrDownstreamNodesFromNodeIndex	(	IN PMIXER_CONTEXT	MixerContext,
		IN PTOPOLOGY	Topology,
		IN ULONG	NodeIndex,
		IN ULONG	bUpStream,
		OUT PULONG	OutNodesCount,
		OUT PULONG	OutNodes
	)

Definition at line 785 of file topology.c.

{
    PTOPOLOGY_NODE TopologyNode;
 
    /* reset visited status */
    MMixerResetTopologyVisitStatus(Topology);
 
    /* sanity check */
    ASSERT(Topology->TopologyNodesCount > NodeIndex);
 
    /* get topology node */
    TopologyNode = &Topology->TopologyNodes[NodeIndex];
 
    /* now visit all upstream pins & nodes */
    MMixerGetUpOrDownstreamNodes(MixerContext, Topology, TopologyNode, bUpStream, OutNodesCount, OutNodes);
 
    /* done */
    return MM_STATUS_SUCCESS;
 
}

Referenced by MMixerAddMixerSourceLines(), and MMixerGetAllUpOrDownstreamNodesFromPinIndex().

MMixerGetAllUpOrDownstreamNodesFromPinIndex()

VOID MMixerGetAllUpOrDownstreamNodesFromPinIndex	(	IN PMIXER_CONTEXT	MixerContext,
		IN PTOPOLOGY	Topology,
		IN ULONG	PinIndex,
		IN ULONG	bUpStream,
		OUT PULONG	OutNodesCount,
		OUT PULONG	OutNodes
	)

Definition at line 878 of file topology.c.

{
    ULONG Index, TopologyNodesCount;
    PPIN Pin;
    PTOPOLOGY_NODE *TopologyNodes;
 
    /* mark them as empty */
    *OutNodesCount = 0;
 
    /* get pin */
    Pin = &Topology->TopologyPins[PinIndex];
 
    if (bUpStream)
    {
        /* use nodes to which a pin is attached to */
        TopologyNodes = Pin->NodesConnectedFrom;
        TopologyNodesCount = Pin->NodesConnectedFromCount;
    }
    else
    {
        /* use nodes which are attached to a node */
        TopologyNodes = Pin->NodesConnectedTo;
        TopologyNodesCount = Pin->NodesConnectedToCount;
    }
 
 
    /* reset visited status */
    MMixerResetTopologyVisitStatus(Topology);
 
    /* sanity check */
    ASSERT(Topology->TopologyPinsCount > PinIndex);
 
    /* now visit all up / down stream pins & nodes */
    for(Index = 0; Index < TopologyNodesCount; Index++)
    {
        /* add node to array */
        MMixerAddPinIndexToArray(MixerContext, TopologyNodes[Index]->NodeIndex, Topology->TopologyNodesCount, OutNodesCount, OutNodes);
 
        /* explore all connected nodes with helper */
        MMixerGetAllUpOrDownstreamNodesFromNodeIndex(MixerContext, Topology, TopologyNodes[Index]->NodeIndex, bUpStream, OutNodesCount, OutNodes);
    }
}

MMixerGetAllUpOrDownstreamPinsFromNodeIndex()

VOID MMixerGetAllUpOrDownstreamPinsFromNodeIndex	(	IN PMIXER_CONTEXT	MixerContext,
		IN PTOPOLOGY	Topology,
		IN ULONG	NodeIndex,
		IN ULONG	bUpStream,
		OUT PULONG	OutPinsCount,
		OUT PULONG	OutPins
	)

Definition at line 713 of file topology.c.

{
    PTOPOLOGY_NODE TopologyNode;
 
    /* reset visited status */
    MMixerResetTopologyVisitStatus(Topology);
 
    /* sanity check */
    ASSERT(Topology->TopologyNodesCount > NodeIndex);
 
    /* get topology node */
    TopologyNode = &Topology->TopologyNodes[NodeIndex];
 
    /* now visit all upstream pins & nodes */
    MMixerGetUpOrDownStreamPins(MixerContext, Topology, TopologyNode, bUpStream, OutPinsCount, OutPins);
}

Referenced by MMixerAddMixerSourceLines(), MMixerGetAllUpOrDownstreamPinsFromPinIndex(), MMixerInitializeFilter(), and MMixerIsNodeConnectedToPin().

MMixerGetAllUpOrDownstreamPinsFromPinIndex()

MIXER_STATUS MMixerGetAllUpOrDownstreamPinsFromPinIndex	(	IN PMIXER_CONTEXT	MixerContext,
		IN PTOPOLOGY	Topology,
		IN ULONG	PinIndex,
		IN ULONG	bUpStream,
		OUT PULONG	OutPinsCount,
		OUT PULONG	OutPins
	)

Definition at line 813 of file topology.c.

{
    ULONG Index, TopologyNodesCount, TopologyPinsCount;
    PPIN Pin;
    PTOPOLOGY_NODE *TopologyNodes;
    PULONG TopologyPins;
 
    /* get pin */
    Pin = &Topology->TopologyPins[PinIndex];
 
    if (bUpStream)
    {
        /* use nodes to which this pin is attached to */
        TopologyNodes = Pin->NodesConnectedFrom;
        TopologyNodesCount = Pin->NodesConnectedFromCount;
 
        /* use pins to which this pin is attached to */
        TopologyPins = Pin->PinConnectedFrom;
        TopologyPinsCount = Pin->PinConnectedFromCount;
 
    }
    else
    {
        /* use nodes which are attached to a pin */
        TopologyNodes = Pin->NodesConnectedTo;
        TopologyNodesCount = Pin->NodesConnectedToCount;
 
        /* use pins which are attached to this pin */
        TopologyPins = Pin->PinConnectedTo;
        TopologyPinsCount = Pin->PinConnectedToCount;
    }
 
 
    /* reset visited status */
    MMixerResetTopologyVisitStatus(Topology);
 
    /* sanity check */
    ASSERT(Topology->TopologyPinsCount > PinIndex);
 
    /* add pins which are directly connected to this pin */
    for(Index = 0; Index < TopologyPinsCount; Index++)
    {
        /* add them to pin array */
        MMixerAddPinIndexToArray(MixerContext, TopologyPins[Index], Topology->TopologyPinsCount, OutPinsCount, OutPins);
    }
 
    /* now visit all up / down stream pins & nodes */
    for(Index = 0; Index < TopologyNodesCount; Index++)
    {
        /* explore all connected pins with helper */
        MMixerGetAllUpOrDownstreamPinsFromNodeIndex(MixerContext, Topology, TopologyNodes[Index]->NodeIndex, bUpStream, OutPinsCount, OutPins);
    }
 
    /* done */
    return MM_STATUS_SUCCESS;
 
}

Referenced by MMixerHandlePhysicalConnection(), and MMixerHandleTopologyFilter().

MMixerGetAudioPinDataRanges()

MIXER_STATUS MMixerGetAudioPinDataRanges	(	IN PMIXER_CONTEXT	MixerContext,
		IN HANDLE	hDevice,
		IN ULONG	PinId,
		IN OUT PKSMULTIPLE_ITEM *	OutMultipleItem
	)

Definition at line 142 of file wave.c.

{
    KSP_PIN PinProperty;
    ULONG BytesReturned = 0;
    MIXER_STATUS Status;
    PKSMULTIPLE_ITEM MultipleItem;
 
    /* retrieve size of data ranges buffer */
    PinProperty.Reserved = 0;
    PinProperty.PinId = PinId;
    PinProperty.Property.Set = KSPROPSETID_Pin;
    PinProperty.Property.Id = KSPROPERTY_PIN_DATARANGES;
    PinProperty.Property.Flags = KSPROPERTY_TYPE_GET;
 
    Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&PinProperty, sizeof(KSP_PIN), (PVOID)NULL, 0, &BytesReturned);
    if (Status != MM_STATUS_MORE_ENTRIES)
    {
        return Status;
    }
 
    MultipleItem = MixerContext->Alloc(BytesReturned);
    if (!MultipleItem)
    {
        /* not enough memory */
        return MM_STATUS_NO_MEMORY;
    }
 
    Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&PinProperty, sizeof(KSP_PIN), (PVOID)MultipleItem, BytesReturned, &BytesReturned);
    if (Status != MM_STATUS_SUCCESS)
    {
        /* failed */
        MixerContext->Free(MultipleItem);
        return Status;
    }
 
    /* save result */
    *OutMultipleItem = MultipleItem;
    return Status;
}

Referenced by MMixerInitializeMidiForFilter(), and MMixerInitializeWaveInfo().

MMixerGetConnectedFromLogicalTopologyPins()

VOID MMixerGetConnectedFromLogicalTopologyPins	(	IN PTOPOLOGY	Topology,
		IN ULONG	NodeIndex,
		OUT PULONG	OutPinCount,
		OUT PULONG	OutPins
	)

Definition at line 1165 of file topology.c.

{
    ULONG Index;
    PTOPOLOGY_NODE Node;
 
    /* sanity check */
    ASSERT(NodeIndex < Topology->TopologyNodesCount);
 
    /* get node */
    Node = &Topology->TopologyNodes[NodeIndex];
 
    for(Index = 0; Index < Node->NodeConnectedFromCount; Index++)
    {
        /* copy logical pin id */
        OutPins[Index] = Node->LogicalPinNodeConnectedFrom[Index];
    }
 
    /* store pin count */
    *OutPinCount = Node->NodeConnectedFromCount;
}

Referenced by MMixerSetGetMuxControlDetails().

MMixerGetConnectionByIndex()

PKSTOPOLOGY_CONNECTION MMixerGetConnectionByIndex	(	IN PKSMULTIPLE_ITEM	MultipleItem,
		IN ULONG	Index
	)

MMixerGetControlTypeFromTopologyNode()

ULONG MMixerGetControlTypeFromTopologyNode

(

IN LPGUID

NodeType

)

Definition at line 139 of file filter.c.

{
    if (IsEqualGUIDAligned(NodeType, (LPGUID)&KSNODETYPE_AGC))
    {
        /* automatic gain control */
        return MIXERCONTROL_CONTROLTYPE_ONOFF;
    }
    else if (IsEqualGUIDAligned(NodeType, (LPGUID)&KSNODETYPE_LOUDNESS))
    {
        /* loudness control */
        return MIXERCONTROL_CONTROLTYPE_LOUDNESS;
    }
    else if (IsEqualGUIDAligned(NodeType, (LPGUID)&KSNODETYPE_MUTE))
    {
        /* mute control */
        return MIXERCONTROL_CONTROLTYPE_MUTE;
    }
    else if (IsEqualGUIDAligned(NodeType, (LPGUID)&KSNODETYPE_TONE))
    {
        /* tone control
         * FIXME
         * MIXERCONTROL_CONTROLTYPE_ONOFF if KSPROPERTY_AUDIO_BASS_BOOST is supported
         * MIXERCONTROL_CONTROLTYPE_BASS if KSPROPERTY_AUDIO_BASS is supported
         * MIXERCONTROL_CONTROLTYPE_TREBLE if KSPROPERTY_AUDIO_TREBLE is supported
         */
        UNIMPLEMENTED;
        return MIXERCONTROL_CONTROLTYPE_ONOFF;
    }
    else if (IsEqualGUIDAligned(NodeType, (LPGUID)&KSNODETYPE_VOLUME))
    {
        /* volume control */
        return MIXERCONTROL_CONTROLTYPE_VOLUME;
    }
    else if (IsEqualGUIDAligned(NodeType, (LPGUID)&KSNODETYPE_PEAKMETER))
    {
        /* peakmeter control */
        return MIXERCONTROL_CONTROLTYPE_PEAKMETER;
    }
    else if (IsEqualGUIDAligned(NodeType, (LPGUID)&KSNODETYPE_MUX))
    {
        /* mux control */
        return MIXERCONTROL_CONTROLTYPE_MUX;
    }
    else if (IsEqualGUIDAligned(NodeType, (LPGUID)&KSNODETYPE_MUX))
    {
        /* mux control */
        return MIXERCONTROL_CONTROLTYPE_MUX;
    }
    else if (IsEqualGUIDAligned(NodeType, (LPGUID)&KSNODETYPE_STEREO_WIDE))
    {
        /* stero wide control */
        return MIXERCONTROL_CONTROLTYPE_FADER;
    }
    else if (IsEqualGUIDAligned(NodeType, (LPGUID)&KSNODETYPE_CHORUS))
    {
        /* chorus control */
        return MIXERCONTROL_CONTROLTYPE_FADER;
    }
    else if (IsEqualGUIDAligned(NodeType, (LPGUID)&KSNODETYPE_REVERB))
    {
        /* reverb control */
        return MIXERCONTROL_CONTROLTYPE_FADER;
    }
    else if (IsEqualGUIDAligned(NodeType, (LPGUID)&KSNODETYPE_SUPERMIX))
    {
        /* supermix control
         * MIXERCONTROL_CONTROLTYPE_MUTE if KSPROPERTY_AUDIO_MUTE is supported
         */
        UNIMPLEMENTED;
        return MIXERCONTROL_CONTROLTYPE_VOLUME;
    }
    /* TODO
     * check for other supported node types
     */
    //UNIMPLEMENTED;
    return 0;
}

Referenced by MMixerAddMixerControl().

MMixerGetDataByDeviceId()

LPMIXER_DATA MMixerGetDataByDeviceId	(	IN PMIXER_LIST	MixerList,
		IN ULONG	DeviceId
	)

Definition at line 738 of file sup.c.

{
    PLIST_ENTRY Entry;
    LPMIXER_DATA MixerData;
 
    Entry = MixerList->MixerData.Flink;
    while(Entry != &MixerList->MixerData)
    {
        MixerData = (LPMIXER_DATA)CONTAINING_RECORD(Entry, MIXER_DATA, Entry);
        if (MixerData->DeviceId == DeviceId)
        {
            return MixerData;
        }
        Entry = Entry->Flink;
    }
    return NULL;
}

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

MMixerGetDataByDeviceName()

LPMIXER_DATA MMixerGetDataByDeviceName	(	IN PMIXER_LIST	MixerList,
		IN LPWSTR	DeviceName
	)

Definition at line 759 of file sup.c.

{
    PLIST_ENTRY Entry;
    LPMIXER_DATA MixerData;
 
    Entry = MixerList->MixerData.Flink;
    while(Entry != &MixerList->MixerData)
    {
        MixerData = (LPMIXER_DATA)CONTAINING_RECORD(Entry, MIXER_DATA, Entry);
        if (wcsicmp(&DeviceName[2], &MixerData->DeviceName[2]) == 0)
        {
            /* found entry */
            return MixerData;
        }
        Entry = Entry->Flink;
    }
    return NULL;
}

Referenced by MMixerHandlePhysicalConnection().

MMixerGetDeviceName()

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

Definition at line 855 of file sup.c.

{
    LPWSTR Name;
    HANDLE hTemp;
    ULONG Length;
    ULONG Type;
    MIXER_STATUS Status;
 
    Status = MixerContext->QueryKeyValue(hKey, L"FriendlyName", (PVOID*)&Name, &Length, &Type);
    if (Status == MM_STATUS_SUCCESS)
    {
        /* copy device name */
        MixerContext->Copy(DeviceName, Name, min(wcslen(Name), MAXPNAMELEN-1) * sizeof(WCHAR));
 
        /* make sure its null terminated */
        DeviceName[MAXPNAMELEN-1] = L'\0';
 
        /* free device name */
        MixerContext->Free(Name);
 
        /* done */
        return Status;
    }
 
    Status = MixerContext->OpenKey(hKey, L"Device Parameters", KEY_READ, &hTemp);
    if (Status != MM_STATUS_SUCCESS)
        return Status;
 
    Status = MixerContext->QueryKeyValue(hTemp, L"FriendlyName", (PVOID*)&Name, &Length, &Type);
    if (Status == MM_STATUS_SUCCESS)
    {
        /* copy device name */
        MixerContext->Copy(DeviceName, Name, min(wcslen(Name), MAXPNAMELEN-1) * sizeof(WCHAR));
 
        /* make sure its null terminated */
        DeviceName[MAXPNAMELEN-1] = L'\0';
 
        /* free device name */
        MixerContext->Free(Name);
    }
 
    MixerContext->CloseKey(hTemp);
    return Status;
}

Referenced by MMixerInitializeFilter(), and MMixerInitializeMidiForFilter().

MMixerGetDeviceNameWithComponentId()

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

Definition at line 807 of file sup.c.

{
    MIXER_STATUS Status;
    KSPROPERTY Property;
    KSCOMPONENTID ComponentId;
    ULONG Length;
    UNICODE_STRING GuidString;
    ULONG ResultLength, KeyType;
    HANDLE hMediaKey, hGuidKey;
    LPWSTR DeviceName;
 
    /* prepare property */
    Property.Flags = KSPROPERTY_TYPE_GET;
    Property.Set = KSPROPSETID_General;
    Property.Id = KSPROPERTY_GENERAL_COMPONENTID;
 
    /* try get component id */
    Status = MixerContext->Control(hMixer, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), &ComponentId, sizeof(KSCOMPONENTID), &Length);
 
    if (Status == MM_STATUS_SUCCESS)
    {
        Status = MixerContext->OpenKey(NULL, L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\MediaCategories", KEY_READ, &hMediaKey);
        if (Status == MM_STATUS_SUCCESS)
        {
            RtlStringFromGUID(&ComponentId.Name, &GuidString);
            Status = MixerContext->OpenKey(hMediaKey, GuidString.Buffer, KEY_READ, &hGuidKey);
            RtlFreeUnicodeString(&GuidString);
            if (Status == MM_STATUS_SUCCESS)
            {
                Status = MixerContext->QueryKeyValue(hGuidKey, L"Name", (PVOID*)&DeviceName, &ResultLength, &KeyType);
                if (Status == MM_STATUS_SUCCESS)
                {
                    MixerContext->Copy(OutDeviceName, DeviceName, min(ResultLength, (MAXPNAMELEN-1)*2));
                    MixerContext->Free(DeviceName);
                }
 
                MixerContext->CloseKey(hGuidKey);
            }
            MixerContext->CloseKey(hMediaKey);
        }
    }
    return Status;
}

Referenced by MMixerInitializeFilter().

MMixerGetFilterPinCount()

ULONG MMixerGetFilterPinCount	(	IN PMIXER_CONTEXT	MixerContext,
		IN HANDLE	hMixer
	)

Definition at line 15 of file filter.c.

{
    KSPROPERTY Pin;
    MIXER_STATUS Status;
    ULONG NumPins, BytesReturned;
 
    /* setup property request */
    Pin.Flags = KSPROPERTY_TYPE_GET;
    Pin.Set = KSPROPSETID_Pin;
    Pin.Id = KSPROPERTY_PIN_CTYPES;
 
    /* query pin count */
    Status = MixerContext->Control(hMixer, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSPROPERTY), (PVOID)&NumPins, sizeof(ULONG), (PULONG)&BytesReturned);
 
    /* check for success */
    if (Status != MM_STATUS_SUCCESS)
        return 0;
 
    return NumPins;
}

Referenced by MMixerBuildTopology().

MMixerGetFilterTopologyProperty()

MIXER_STATUS MMixerGetFilterTopologyProperty	(	IN PMIXER_CONTEXT	MixerContext,
		IN HANDLE	hMixer,
		IN ULONG	PropertyId,
		OUT PKSMULTIPLE_ITEM *	OutMultipleItem
	)

Definition at line 39 of file filter.c.

{
    KSPROPERTY Property;
    PKSMULTIPLE_ITEM MultipleItem;
    MIXER_STATUS Status;
    ULONG BytesReturned;
 
    /* setup property request */
    Property.Id = PropertyId;
    Property.Flags = KSPROPERTY_TYPE_GET;
    Property.Set = KSPROPSETID_Topology;
 
    /* query for the size */
    Status = MixerContext->Control(hMixer, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), NULL, 0, &BytesReturned);
 
    if (Status != MM_STATUS_MORE_ENTRIES)
        return Status;
 
    /* sanity check */
    ASSERT(BytesReturned);
 
    /* allocate an result buffer */
    MultipleItem = (PKSMULTIPLE_ITEM)MixerContext->Alloc(BytesReturned);
 
    if (!MultipleItem)
    {
        /* not enough memory */
        return MM_STATUS_NO_MEMORY;
    }
 
    /* query again with allocated buffer */
    Status = MixerContext->Control(hMixer, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)MultipleItem, BytesReturned, &BytesReturned);
 
    if (Status != MM_STATUS_SUCCESS)
    {
        /* failed */
        MixerContext->Free((PVOID)MultipleItem);
        return Status;
    }
 
    /* store result */
    *OutMultipleItem = MultipleItem;
 
    /* done */
    return Status;
}

Referenced by MMixerBuildTopology().

MMixerGetMixerByName()

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

Definition at line 194 of file sup.c.

{
    LPMIXER_INFO MixerInfo;
    PLIST_ENTRY Entry;
 
    Entry = MixerList->MixerList.Flink;
    while(Entry != &MixerList->MixerList)
    {
        MixerInfo = (LPMIXER_INFO)CONTAINING_RECORD(Entry, MIXER_INFO, Entry);
 
        DPRINT1("MixerName %S MixerName %S\n", MixerInfo->MixCaps.szPname, MixerName);
        if (wcsicmp(MixerInfo->MixCaps.szPname, MixerName) == 0)
        {
            *OutMixerInfo = MixerInfo;
            return MM_STATUS_SUCCESS;
        }
        /* move to next mixer entry */
        Entry = Entry->Flink;
    }
 
    return MM_STATUS_UNSUCCESSFUL;
}

MMixerGetMixerControlById()

MIXER_STATUS MMixerGetMixerControlById	(	LPMIXER_INFO	MixerInfo,
		DWORD	dwControlID,
		LPMIXERLINE_EXT *	MixerLine,
		LPMIXERCONTROL_EXT *	MixerControl,
		PULONG	NodeId
	)

Definition at line 281 of file sup.c.

{
    PLIST_ENTRY Entry, ControlEntry;
    LPMIXERLINE_EXT MixerLineSrc;
    LPMIXERCONTROL_EXT MixerControl;
 
    /* get first entry */
    Entry = MixerInfo->LineList.Flink;
 
    while(Entry != &MixerInfo->LineList)
    {
        MixerLineSrc = (LPMIXERLINE_EXT)CONTAINING_RECORD(Entry, MIXERLINE_EXT, Entry);
 
        ControlEntry = MixerLineSrc->ControlsList.Flink;
        while(ControlEntry != &MixerLineSrc->ControlsList)
        {
            MixerControl = (LPMIXERCONTROL_EXT)CONTAINING_RECORD(ControlEntry, MIXERCONTROL_EXT, Entry);
            if (MixerControl->Control.dwControlID == dwControlID)
            {
                if (OutMixerLine)
                    *OutMixerLine = MixerLineSrc;
                if (OutMixerControl)
                    *OutMixerControl = MixerControl;
                if (NodeId)
                    *NodeId = MixerControl->NodeID;
                return MM_STATUS_SUCCESS;
            }
            ControlEntry = ControlEntry->Flink;
        }
        Entry = Entry->Flink;
    }
 
    return MM_STATUS_UNSUCCESSFUL;
}

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

MMixerGetMixerInfoByIndex()

LPMIXER_INFO MMixerGetMixerInfoByIndex	(	IN PMIXER_CONTEXT	MixerContext,
		IN ULONG	MixerIndex
	)

Definition at line 161 of file sup.c.

{
    LPMIXER_INFO MixerInfo;
    PLIST_ENTRY Entry;
    PMIXER_LIST MixerList;
    ULONG Index = 0;
 
    /* get mixer list */
    MixerList = (PMIXER_LIST)MixerContext->MixerContext;
 
    if (!MixerList->MixerListCount)
        return NULL;
 
    Entry = MixerList->MixerList.Flink;
 
    while(Entry != &MixerList->MixerList)
    {
        MixerInfo = (LPMIXER_INFO)CONTAINING_RECORD(Entry, MIXER_INFO, Entry);
 
        if (Index == MixerIndex)
            return MixerInfo;
 
        /* move to next mixer entry */
        Index++;
        Entry = Entry->Flink;
    }
 
    return NULL;
}

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

MMixerGetNextNodesFromNodeIndex()

VOID MMixerGetNextNodesFromNodeIndex	(	IN PMIXER_CONTEXT	MixerContext,
		IN PTOPOLOGY	Topology,
		IN ULONG	NodeIndex,
		IN ULONG	bUpStream,
		OUT PULONG	OutNodesCount,
		OUT PULONG	OutNodes
	)

Definition at line 972 of file topology.c.

{
    TOPOLOGY_NODE **TopologyNodes;
    ULONG TopologyNodesCount;
    ULONG Index;
 
    /* sanity check */
    ASSERT(NodeIndex < Topology->TopologyNodesCount);
 
    if (bUpStream)
    {
        /* get up stream nodes */
        TopologyNodes = Topology->TopologyNodes[NodeIndex].NodeConnectedFrom;
        TopologyNodesCount = Topology->TopologyNodes[NodeIndex].NodeConnectedFromCount;
    }
    else
    {
        /* get down stream nodes */
        TopologyNodes = Topology->TopologyNodes[NodeIndex].NodeConnectedTo;
        TopologyNodesCount = Topology->TopologyNodes[NodeIndex].NodeConnectedToCount;
    }
 
    /* store topology nodes ids */
    for(Index = 0; Index < TopologyNodesCount; Index++)
    {
        OutNodes[Index] = TopologyNodes[Index]->NodeIndex;
    }
 
    /* store topology nodes count */
    *OutNodesCount = TopologyNodesCount;
}

Referenced by MMixerAddMixerControl(), MMixerCountMixerControls(), and MMixerSetGetMuxControlDetails().

MMixerGetNextNodesFromPinIndex()

VOID MMixerGetNextNodesFromPinIndex	(	IN PMIXER_CONTEXT	MixerContext,
		IN PTOPOLOGY	Topology,
		IN ULONG	PinIndex,
		IN ULONG	bUpStream,
		OUT PULONG	OutNodesCount,
		OUT PULONG	OutNodes
	)

Definition at line 929 of file topology.c.

{
    PPIN Pin;
    TOPOLOGY_NODE **TopologyNodes;
    ULONG TopologyNodesCount;
    ULONG Index;
 
    /* sanity check */
    ASSERT(PinIndex < Topology->TopologyPinsCount);
 
    /* get pin */
    Pin = &Topology->TopologyPins[PinIndex];
 
    if (bUpStream)
    {
        /* get up stream nodes */
        TopologyNodes = Pin->NodesConnectedFrom;
        TopologyNodesCount = Pin->NodesConnectedFromCount;
    }
    else
    {
        /* get down stream nodes */
        TopologyNodes = Pin->NodesConnectedTo;
        TopologyNodesCount = Pin->NodesConnectedToCount;
    }
 
    /* store topology nodes ids */
    for(Index = 0; Index < TopologyNodesCount; Index++)
    {
        OutNodes[Index] = TopologyNodes[Index]->NodeIndex;
    }
 
    /* store topology nodes count */
    *OutNodesCount = TopologyNodesCount;
}

Referenced by MMixerCountMixerControls().

MMixerGetNodeIndexes()

MIXER_STATUS MMixerGetNodeIndexes	(	IN PMIXER_CONTEXT	MixerContext,
		IN PKSMULTIPLE_ITEM	MultipleItem,
		IN ULONG	NodeIndex,
		IN ULONG	bNode,
		IN ULONG	bFrom,
		OUT PULONG	NodeReferenceCount,
		OUT PULONG *	NodeReference
	)

MMixerGetNodeIndexFromGuid()

ULONG MMixerGetNodeIndexFromGuid	(	IN PTOPOLOGY	Topology,
		IN const GUID *	NodeType
	)

Definition at line 694 of file topology.c.

{
    ULONG Index;
 
    for(Index = 0; Index < Topology->TopologyNodesCount; Index++)
    {
        if (IsEqualGUIDAligned(NodeType, &Topology->TopologyNodes[Index].NodeType))
        {
            return Index;
        }
    }
 
    return MAXULONG;
}

Referenced by MMixerSetupFilter().

MMixerGetNodeType()

LPGUID MMixerGetNodeType	(	IN PKSMULTIPLE_ITEM	MultipleItem,
		IN ULONG	Index
	)

Definition at line 245 of file sup.c.

{
    LPGUID NodeType;
 
    ASSERT(Index < MultipleItem->Count);
 
    NodeType = (LPGUID)(MultipleItem + 1);
    return &NodeType[Index];
}

MMixerGetNodeTypeFromTopology()

LPGUID MMixerGetNodeTypeFromTopology	(	IN PTOPOLOGY	Topology,
		IN ULONG	NodeIndex
	)

Definition at line 1191 of file topology.c.

{
    /* sanity check */
    ASSERT(NodeIndex < Topology->TopologyNodesCount);
 
    return &Topology->TopologyNodes[NodeIndex].NodeType;
}

Referenced by MMixerAddMixerControl(), and MMixerAddMixerControlsToMixerLineByNodeIndexArray().

MMixerGetPhysicalConnection()

MIXER_STATUS MMixerGetPhysicalConnection	(	IN PMIXER_CONTEXT	MixerContext,
		IN HANDLE	hMixer,
		IN ULONG	PinId,
		OUT PKSPIN_PHYSICALCONNECTION *	OutConnection
	)

Definition at line 91 of file filter.c.

{
    KSP_PIN Pin;
    MIXER_STATUS Status;
    ULONG BytesReturned;
    PKSPIN_PHYSICALCONNECTION Connection;
 
    /* setup the request */
    Pin.Property.Flags = KSPROPERTY_TYPE_GET;
    Pin.Property.Id = KSPROPERTY_PIN_PHYSICALCONNECTION;
    Pin.Property.Set = KSPROPSETID_Pin;
    Pin.PinId = PinId;
 
    /* query the pin for the physical connection */
    Status = MixerContext->Control(hMixer, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), NULL, 0, &BytesReturned);
 
    if (Status == MM_STATUS_UNSUCCESSFUL)
    {
        /* pin does not have a physical connection */
        return Status;
    }
    DPRINT("Status %u BytesReturned %lu\n", Status, BytesReturned);
    Connection = (PKSPIN_PHYSICALCONNECTION)MixerContext->Alloc(BytesReturned);
    if (!Connection)
    {
        /* not enough memory */
        return MM_STATUS_NO_MEMORY;
    }
 
    /* query the pin for the physical connection */
    Status = MixerContext->Control(hMixer, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)Connection, BytesReturned, &BytesReturned);
    if (Status != MM_STATUS_SUCCESS)
    {
        /* failed to query the physical connection */
        MixerContext->Free(Connection);
        return Status;
    }
 
    // store connection
    *OutConnection = Connection;
    return Status;
}

Referenced by MMixerApplyOutputFilterHack(), MMixerGetComponentAndTargetType(), and MMixerInitializeFilter().

MMixerGetPinDataFlowAndCommunication()

MIXER_STATUS MMixerGetPinDataFlowAndCommunication	(	IN PMIXER_CONTEXT	MixerContext,
		IN HANDLE	hDevice,
		IN ULONG	PinId,
		OUT PKSPIN_DATAFLOW	DataFlow,
		OUT PKSPIN_COMMUNICATION	Communication
	)

Definition at line 15 of file midi.c.

{
    KSP_PIN Pin;
    ULONG BytesReturned;
    MIXER_STATUS Status;
 
    /* setup request */
    Pin.PinId = PinId;
    Pin.Reserved = 0;
    Pin.Property.Flags = KSPROPERTY_TYPE_GET;
    Pin.Property.Id = KSPROPERTY_PIN_DATAFLOW;
    Pin.Property.Set = KSPROPSETID_Pin;
 
    /* get pin dataflow */
    Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)DataFlow, sizeof(KSPIN_DATAFLOW), &BytesReturned);
    if (Status != MM_STATUS_SUCCESS)
    {
        /* failed to retrieve dataflow */
        return Status;
    }
 
    /* setup communication request */
    Pin.Property.Id = KSPROPERTY_PIN_COMMUNICATION;
 
    /* get pin communication */
    Status = MixerContext->Control(hDevice, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)Communication, sizeof(KSPIN_COMMUNICATION), &BytesReturned);
 
    return Status;
}

Referenced by MMixerCheckFilterPinMidiSupport(), and MMixerGetComponentAndTargetType().

MMixerGetSourceMixerLineByComponentType()

LPMIXERLINE_EXT MMixerGetSourceMixerLineByComponentType	(	LPMIXER_INFO	MixerInfo,
		DWORD	dwComponentType
	)

Definition at line 258 of file sup.c.

{
    PLIST_ENTRY Entry;
    LPMIXERLINE_EXT MixerLineSrc;
 
    /* get first entry */
    Entry = MixerInfo->LineList.Flink;
 
    while(Entry != &MixerInfo->LineList)
    {
        MixerLineSrc = (LPMIXERLINE_EXT)CONTAINING_RECORD(Entry, MIXERLINE_EXT, Entry);
        if (MixerLineSrc->Line.dwComponentType == dwComponentType)
            return MixerLineSrc;
 
        Entry = Entry->Flink;
    }
 
    return NULL;
}

Referenced by MMixerGetLineInfo().

MMixerGetSourceMixerLineByLineId()

LPMIXERLINE_EXT MMixerGetSourceMixerLineByLineId	(	LPMIXER_INFO	MixerInfo,
		DWORD	dwLineID
	)

Definition at line 221 of file sup.c.

{
    PLIST_ENTRY Entry;
    LPMIXERLINE_EXT MixerLineSrc;
 
    /* get first entry */
    Entry = MixerInfo->LineList.Flink;
 
    while(Entry != &MixerInfo->LineList)
    {
        MixerLineSrc = (LPMIXERLINE_EXT)CONTAINING_RECORD(Entry, MIXERLINE_EXT, Entry);
        DPRINT("dwLineID %x dwLineID %x MixerLineSrc %p\n", MixerLineSrc->Line.dwLineID, dwLineID, MixerLineSrc);
        if (MixerLineSrc->Line.dwLineID == dwLineID)
            return MixerLineSrc;
 
        Entry = Entry->Flink;
    }
 
    return NULL;
}

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

MMixerGetTopologyPinCount()

VOID MMixerGetTopologyPinCount	(	IN PTOPOLOGY	Topology,
		OUT PULONG	PinCount
	)

Definition at line 1011 of file topology.c.

{
    /* store pin count */
    *PinCount = Topology->TopologyPinsCount;
}

Referenced by MMixerHandleAlternativeMixers(), and MMixerInitializeMidiForFilter().

MMixerHandleAlternativeMixers()

VOID MMixerHandleAlternativeMixers	(	IN PMIXER_CONTEXT	MixerContext,
		IN PMIXER_LIST	MixerList,
		IN LPMIXER_DATA	MixerData,
		IN PTOPOLOGY	Topology
	)

Definition at line 1682 of file controls.c.

{
    ULONG Index, PinCount, Reserved;
    MIXER_STATUS Status;
    ULONG DestinationLineID, LineTerminator;
    LPMIXERLINE_EXT DstLine;
 
    DPRINT("DeviceName %S\n", MixerData->DeviceName);
 
    /* get topology pin count */
    MMixerGetTopologyPinCount(Topology, &PinCount);
 
    for(Index = 0; Index < PinCount; Index++)
    {
        MMixerIsTopologyPinReserved(Topology, Index, &Reserved);
 
        /* check if it has already been reserved */
        if (Reserved)
        {
            /* pin has already been reserved */
            continue;
        }
 
        DPRINT("MixerName %S Available PinID %lu\n", MixerData->DeviceName, Index);
 
        /* sanity check */
        //ASSERT(MixerData->MixerInfo);
 
        if (!MixerData->MixerInfo)
        {
            DPRINT1("Expected mixer info\n");
            continue;
        }
 
        /* build the destination line */
        Status = MMixerBuildMixerDestinationLine(MixerContext, MixerData->MixerInfo, MixerData->hDevice, Index, TRUE);
        if (Status != MM_STATUS_SUCCESS)
        {
            /* failed to build destination line */
            continue;
        }
 
        /* calculate destination line id */
        DestinationLineID = (DESTINATION_LINE + MixerData->MixerInfo->MixCaps.cDestinations-1);
 
        /* add mixer controls to destination line */
        Status = MMixerAddMixerControlsToDestinationLine(MixerContext, MixerData->MixerInfo, MixerData->hDevice, MixerData->Topology, Index, TRUE, DestinationLineID,  &LineTerminator);
        if (Status == MM_STATUS_SUCCESS)
        {
            /* now add the rest of the source lines */
            Status = MMixerAddMixerSourceLines(MixerContext, MixerData->MixerInfo, MixerData->hDevice, MixerData->Topology, DestinationLineID, LineTerminator);
        }
 
        /* mark pin as consumed */
        MMixerSetTopologyPinReserved(Topology, Index);
 
        /* now grab destination line */
        DstLine = MMixerGetSourceMixerLineByLineId(MixerData->MixerInfo, DestinationLineID);
 
        /* set type and target as undefined */
        DstLine->Line.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_UNDEFINED;
        DstLine->Line.Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
        DstLine->Line.Target.vDriverVersion = 0;
        DstLine->Line.Target.wMid = 0;
        DstLine->Line.Target.wPid = 0;
    }
}

Referenced by MMixerInitialize().

MMixerInitializeMidiForFilter()

VOID MMixerInitializeMidiForFilter	(	IN PMIXER_CONTEXT	MixerContext,
		IN PMIXER_LIST	MixerList,
		IN LPMIXER_DATA	MixerData,
		IN PTOPOLOGY	Topology
	)

Definition at line 172 of file midi.c.

{
    ULONG PinCount, Index;
    MIXER_STATUS Status;
    PKSMULTIPLE_ITEM MultipleItem;
    WCHAR szPname[MAXPNAMELEN];
 
    /* get filter pin count */
    MMixerGetTopologyPinCount(Topology, &PinCount);
 
    /* get mixer name */
    if (MMixerGetDeviceName(MixerContext, szPname, MixerData->hDeviceInterfaceKey) != MM_STATUS_SUCCESS)
    {
        /* clear name */
        szPname[0] = 0;
    }
 
    /* iterate all pins and check for KSDATARANGE_MUSIC support */
    for(Index = 0; Index < PinCount; Index++)
    {
        /* get audio pin data ranges */
        Status = MMixerGetAudioPinDataRanges(MixerContext, MixerData->hDevice, Index, &MultipleItem);
 
        /* check for success */
        if (Status == MM_STATUS_SUCCESS)
        {
            /* check if there is support KSDATARANGE_MUSIC */
            MMixerCheckFilterPinMidiSupport(MixerContext, MixerList, MixerData, Index, MultipleItem, szPname);
        }
    }
}

MMixerInitializePinConnect()

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

Definition at line 904 of file sup.c.

{
    PinConnect->Interface.Set = KSINTERFACESETID_Standard;
    PinConnect->Interface.Id = KSINTERFACE_STANDARD_STREAMING;
    PinConnect->Interface.Flags = 0;
    PinConnect->Medium.Set = KSMEDIUMSETID_Standard;
    PinConnect->Medium.Id = KSMEDIUM_TYPE_ANYINSTANCE;
    PinConnect->Medium.Flags = 0;
    PinConnect->PinToHandle = NULL;
    PinConnect->PinId = PinId;
    PinConnect->Priority.PriorityClass = KSPRIORITY_NORMAL;
    PinConnect->Priority.PrioritySubClass = 1;
}

Referenced by MMixerOpenMidiPin(), and MMixerOpenWavePin().

MMixerInitializeWaveInfo()

MIXER_STATUS MMixerInitializeWaveInfo	(	IN PMIXER_CONTEXT	MixerContext,
		IN PMIXER_LIST	MixerList,
		IN LPMIXER_DATA	MixerData,
		IN LPWSTR	DeviceName,
		IN ULONG	bWaveIn,
		IN ULONG	PinCount,
		IN PULONG	Pins
	)

Definition at line 330 of file wave.c.

{
    MIXER_STATUS Status;
    PKSMULTIPLE_ITEM MultipleItem;
    PKSDATARANGE_AUDIO DataRangeAudio;
    LPWAVE_INFO WaveInfo;
 
    WaveInfo = (LPWAVE_INFO)MixerContext->Alloc(sizeof(WAVE_INFO));
    if (!WaveInfo)
        return MM_STATUS_NO_MEMORY;
 
    if (PinCount > 1)
    {
        /* FIXME support multiple pins for wave device */
        DPRINT1("Implement support for multiple pins\n");
        //ASSERT(PinCount == 1);
    }
 
    /* initialize wave info */
    WaveInfo->DeviceId = MixerData->DeviceId;
    WaveInfo->PinId = Pins[0];
 
    /* sanity check */
    ASSERT(wcslen(DeviceName) < MAXPNAMELEN);
 
    /* copy device name */
    if (bWaveIn)
    {
        wcscpy(WaveInfo->u.InCaps.szPname, DeviceName);
    }
    else
    {
        wcscpy(WaveInfo->u.OutCaps.szPname, DeviceName);
    }
 
    /* FIXME determine manufacturer / product id */
    if (bWaveIn)
    {
        WaveInfo->u.InCaps.wMid = MM_MICROSOFT;
        WaveInfo->u.InCaps.wPid = MM_PID_UNMAPPED;
        WaveInfo->u.InCaps.vDriverVersion = 1;
    }
    else
    {
        WaveInfo->u.OutCaps.wMid = MM_MICROSOFT;
        WaveInfo->u.OutCaps.wPid = MM_PID_UNMAPPED;
        WaveInfo->u.OutCaps.vDriverVersion = 1;
    }
 
    /* get audio pin data ranges */
    Status = MMixerGetAudioPinDataRanges(MixerContext, MixerData->hDevice, Pins[0], &MultipleItem);
    if (Status != MM_STATUS_SUCCESS)
    {
        /* failed to get audio pin data ranges */
        MixerContext->Free(WaveInfo);
        return MM_STATUS_UNSUCCESSFUL;
    }
 
    /* find an KSDATARANGE_AUDIO range */
    Status = MMixerFindAudioDataRange(MultipleItem, &DataRangeAudio);
    if (Status != MM_STATUS_SUCCESS)
    {
        /* failed to find audio pin data range */
        MixerContext->Free(MultipleItem);
        MixerContext->Free(WaveInfo);
        return MM_STATUS_UNSUCCESSFUL;
    }
 
    /* store channel count */
    if (bWaveIn)
    {
        WaveInfo->u.InCaps.wChannels = DataRangeAudio->MaximumChannels;
    }
    else
    {
       WaveInfo->u.OutCaps.wChannels = DataRangeAudio->MaximumChannels;
    }
 
    /* get all supported formats */
    MMixerCheckFormat(DataRangeAudio, WaveInfo, bWaveIn);
 
    /* free dataranges buffer */
    MixerContext->Free(MultipleItem);
 
    if (bWaveIn)
    {
        InsertTailList(&MixerList->WaveInList, &WaveInfo->Entry);
        MixerList->WaveInListCount++;
    }
    else
    {
        InsertTailList(&MixerList->WaveOutList, &WaveInfo->Entry);
        MixerList->WaveOutListCount++;
    }
 
    return MM_STATUS_SUCCESS;
}

Referenced by MMixerInitializeFilter().

MMixerIsNodeConnectedToPin()

MIXER_STATUS MMixerIsNodeConnectedToPin	(	IN PMIXER_CONTEXT	MixerContext,
		IN PTOPOLOGY	Topology,
		IN ULONG	NodeIndex,
		IN ULONG	PinId,
		IN ULONG	bUpStream,
		OUT PULONG	bConnected
	)

Definition at line 1119 of file topology.c.

{
    MIXER_STATUS Status;
    ULONG Index, PinsCount;
    PULONG Pins;
 
    /* allocate pin index array */
    Status = MMixerAllocateTopologyPinArray(MixerContext, Topology, &Pins);
 
    if (Status != MM_STATUS_SUCCESS)
    {
        /* failed to allocate */
        return Status;
    }
 
    /* now get connected pins */
    PinsCount = 0;
    MMixerGetAllUpOrDownstreamPinsFromNodeIndex(MixerContext, Topology, NodeIndex, bUpStream, &PinsCount, Pins);
 
    /* set to false */
    *bConnected = FALSE;
 
    for(Index = 0; Index < PinsCount; Index++)
    {
        if (Pins[Index] == PinId)
        {
            /* pin is connected */
            *bConnected = TRUE;
            break;
        }
    }
 
    /* free pin index array */
    MixerContext->Free(Pins);
 
    /* done */
    return MM_STATUS_SUCCESS;
}

Referenced by MMixerAddMixerSourceLines().

MMixerIsNodeTerminator()

VOID MMixerIsNodeTerminator	(	IN PTOPOLOGY	Topology,
		IN ULONG	NodeIndex,
		OUT ULONG *	bTerminator
	)

Definition at line 1084 of file topology.c.

{
    /* sanity check */
    ASSERT(NodeIndex < Topology->TopologyNodesCount);
 
    /* check if node has multiple parents */
    if (Topology->TopologyNodes[NodeIndex].NodeConnectedFromCount > 1)
    {
        /* node is connected to multiple other nodes */
        *bTerminator = TRUE;
 
        /* done */
        return;
    }
 
    /* check if node is mux / sum node */
    if (IsEqualGUIDAligned(&Topology->TopologyNodes[NodeIndex].NodeType, &KSNODETYPE_SUM) ||
        IsEqualGUIDAligned(&Topology->TopologyNodes[NodeIndex].NodeType, &KSNODETYPE_MUX))
    {
        /* classic terminator */
        *bTerminator = TRUE;
 
        /* done */
        return;
 
    }
 
    /* node is not a terminator */
    *bTerminator = FALSE;
}

Referenced by MMixerCountMixerControls().

MMixerIsTopologyNodeReserved()

VOID MMixerIsTopologyNodeReserved	(	IN PTOPOLOGY	Topology,
		IN ULONG	NodeIndex,
		OUT PULONG	bReserved
	)

Definition at line 1239 of file topology.c.

{
    /* sanity check */
    ASSERT(NodeIndex < Topology->TopologyNodesCount);
 
    /* get reserved status */
    *bReserved = Topology->TopologyNodes[NodeIndex].Reserved;
}

Referenced by MMixerAddMixerControlsToMixerLineByNodeIndexArray().

MMixerIsTopologyPinReserved()

VOID MMixerIsTopologyPinReserved	(	IN PTOPOLOGY	Topology,
		IN ULONG	PinId,
		OUT PULONG	bReserved
	)

Definition at line 1214 of file topology.c.

{
    /* sanity check */
    ASSERT(PinId < Topology->TopologyPinsCount);
 
    /* get reserved status */
    *bReserved = Topology->TopologyPins[PinId].Reserved;
}

Referenced by MMixerHandleAlternativeMixers().

MMixerPrintTopology()

VOID MMixerPrintTopology

(

)

Referenced by MMixerCountMixerControls(), and MMixerCreateTopology().

MMixerRemoveEvent()

MIXER_STATUS MMixerRemoveEvent	(	IN PMIXER_CONTEXT	MixerContext,
		IN OUT LPMIXER_INFO	MixerInfo,
		IN PVOID	MixerEventContext,
		IN PMIXER_EVENT	MixerEventRoutine
	)

Definition at line 1882 of file controls.c.

{
    PLIST_ENTRY EventList;
    PEVENT_NOTIFICATION_ENTRY NotificationEntry;
 
    /* Lookup through mixers */
    EventList = MixerInfo->EventList.Flink;
    while(EventList != &MixerInfo->EventList)
    {
        NotificationEntry = CONTAINING_RECORD(EventList, EVENT_NOTIFICATION_ENTRY, Entry);
        EventList = EventList->Flink;
        /* TODO: find a better way to identify an event ? */
        if(NotificationEntry->MixerEventRoutine == MixerEventRoutine &&
                NotificationEntry->MixerEventContext == MixerEventContext)
        {
            DPRINT1("Freeing entry %p\n", NotificationEntry);
            /* We found the event to remove */
            RemoveEntryList(&NotificationEntry->Entry);
            MixerContext->Free(NotificationEntry);
        }
    }
    return MM_STATUS_SUCCESS;
}

Referenced by MMixerClose().

MMixerSetGetControlDetails()

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 at line 219 of file filter.c.

{
    KSNODEPROPERTY_AUDIO_CHANNEL Property;
    MIXER_STATUS Status;
    LONG Value;
    ULONG BytesReturned;
 
    if (bSet)
        Value = *InputValue;
 
    /* setup the request */
    RtlZeroMemory(&Property, sizeof(KSNODEPROPERTY_AUDIO_CHANNEL));
 
    Property.NodeProperty.NodeId = NodeId;
    Property.NodeProperty.Property.Id = PropertyId;
    Property.NodeProperty.Property.Flags = KSPROPERTY_TYPE_TOPOLOGY;
    Property.NodeProperty.Property.Set = KSPROPSETID_Audio;
    Property.Channel = Channel;
    Property.Reserved = 0;
 
    if (bSet)
        Property.NodeProperty.Property.Flags |= KSPROPERTY_TYPE_SET;
    else
        Property.NodeProperty.Property.Flags |= KSPROPERTY_TYPE_GET;
 
    /* send the request */
    Status = MixerContext->Control(hMixer, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSNODEPROPERTY_AUDIO_CHANNEL), (PVOID)&Value, sizeof(LONG), &BytesReturned);
 
    if (!bSet && Status == MM_STATUS_SUCCESS)
    {
        *InputValue = Value;
    }
 
    DPRINT("Status %x bSet %u NodeId %u Value %d PropertyId %u\n", Status, bSet, NodeId, Value, PropertyId);
    return Status;
}

Referenced by MMixerSetGetMuteControlDetails(), 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.

{
    LPMIXERCONTROLDETAILS_BOOLEAN Input;
    LONG Value;
    MIXER_STATUS Status;
 
    if (MixerControlDetails->cbDetails != sizeof(MIXERCONTROLDETAILS_BOOLEAN))
        return MM_STATUS_INVALID_PARAMETER;
 
    /* get input */
    Input = (LPMIXERCONTROLDETAILS_BOOLEAN)MixerControlDetails->paDetails;
 
    /* FIXME SEH */
    if (bSet)
        Value = Input->fValue;
 
    /* set control details */
    Status = MMixerSetGetControlDetails(MixerContext, MixerControl->hDevice, MixerControl->NodeID, bSet, KSPROPERTY_AUDIO_MUTE, 0, &Value);
 
    if (Status != MM_STATUS_SUCCESS)
        return Status;
 
    /* FIXME SEH */
    if (!bSet)
    {
        Input->fValue = Value;
        return Status;
    }
    else
    {
        /* notify wdmaud clients MM_MIXM_LINE_CHANGE dwLineID */
        MMixerNotifyControlChange(MixerContext, MixerInfo, MM_MIXM_LINE_CHANGE, dwLineID);
    }
 
    return Status;
}

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,
		LPMIXERCONTROL_EXT	MixerControl,
		IN LPMIXERCONTROLDETAILS	MixerControlDetails,
		LPMIXERLINE_EXT	MixerLine
	)

Referenced by MMixerGetControlDetails(), and MMixerSetControlDetails().

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.

{
    LPMIXERCONTROLDETAILS_UNSIGNED Input;
    LONG Value;
    ULONG Index, Channel = 0;
    ULONG dwValue;
    MIXER_STATUS Status;
    LPMIXERVOLUME_DATA VolumeData;
 
    if (MixerControlDetails->cbDetails != sizeof(MIXERCONTROLDETAILS_SIGNED))
        return MM_STATUS_INVALID_PARAMETER;
 
    VolumeData = (LPMIXERVOLUME_DATA)MixerControl->ExtraData;
    if (!VolumeData)
        return MM_STATUS_UNSUCCESSFUL;
 
    /* get input */
    Input = (LPMIXERCONTROLDETAILS_UNSIGNED)MixerControlDetails->paDetails;
    if (!Input)
        return MM_STATUS_UNSUCCESSFUL; /* to prevent dereferencing NULL */
 
    if (bSet)
    {
        /* FIXME SEH */
        Value = Input->dwValue;
        Index = Value / VolumeData->InputSteppingDelta;
 
        if (Index >= VolumeData->ValuesCount)
        {
            DPRINT1("Index %u out of bounds %u \n", Index, VolumeData->ValuesCount);
            return MM_STATUS_INVALID_PARAMETER;
        }
 
        Value = VolumeData->Values[Index];
    }
 
    /* set control details */
    if (bSet)
    {
        /* TODO */
        Status = MMixerSetGetControlDetails(MixerContext, MixerControl->hDevice, NodeId, bSet, KSPROPERTY_AUDIO_VOLUMELEVEL, 0, &Value);
        Status = MMixerSetGetControlDetails(MixerContext, MixerControl->hDevice, NodeId, bSet, KSPROPERTY_AUDIO_VOLUMELEVEL, 1, &Value);
    }
    else
    {
        Status = MMixerSetGetControlDetails(MixerContext, MixerControl->hDevice, NodeId, bSet, KSPROPERTY_AUDIO_VOLUMELEVEL, Channel, &Value);
    }
 
    if (!bSet)
    {
        dwValue = MMixerGetVolumeControlIndex(VolumeData, (LONG)Value);
        /* FIXME SEH */
        Input->dwValue = dwValue;
    }
    else
    {
        /* notify clients of a line change  MM_MIXM_CONTROL_CHANGE with MixerControl->dwControlID */
        MMixerNotifyControlChange(MixerContext, MixerInfo, MM_MIXM_CONTROL_CHANGE, MixerControl->Control.dwControlID);
    }
    return Status;
}

Referenced by MMixerGetControlDetails(), and MMixerSetControlDetails().

MMixerSetTopologyNodeReserved()

VOID MMixerSetTopologyNodeReserved	(	IN PTOPOLOGY	Topology,
		IN ULONG	NodeIndex
	)

Definition at line 1227 of file topology.c.

{
    /* sanity check */
    ASSERT(NodeIndex < Topology->TopologyNodesCount);
 
    /* set reserved */
    Topology->TopologyNodes[NodeIndex].Reserved = TRUE;
}

Referenced by MMixerAddMixerControlsToMixerLineByNodeIndexArray().

MMixerSetTopologyPinReserved()

VOID MMixerSetTopologyPinReserved	(	IN PTOPOLOGY	Topology,
		IN ULONG	PinId
	)

Definition at line 1202 of file topology.c.

{
    /* sanity check */
    ASSERT(PinId < Topology->TopologyPinsCount);
 
    /* set reserved */
    Topology->TopologyPins[PinId].Reserved = TRUE;
}

Referenced by MMixerAddMixerSourceLines(), MMixerHandleAlternativeMixers(), MMixerHandlePhysicalConnection(), MMixerHandleTopologyFilter(), and MMixerInitializeFilter().

MMixerSetupFilter()

MIXER_STATUS MMixerSetupFilter	(	IN PMIXER_CONTEXT	MixerContext,
		IN PMIXER_LIST	MixerList,
		IN LPMIXER_DATA	MixerData,
		IN PULONG	DeviceCount
	)

Definition at line 1755 of file controls.c.

{
    MIXER_STATUS Status = MM_STATUS_SUCCESS;
    PTOPOLOGY Topology;
    ULONG NodeIndex;
    LPMIXER_INFO MixerInfo = NULL;
 
    /* check if topology has already been built */
    if (MixerData->Topology == NULL)
    {
        /* build topology */
        Status = MMixerBuildTopology(MixerContext, MixerData, &Topology);
 
        if (Status != MM_STATUS_SUCCESS)
        {
            /* failed to build topology */
            return Status;
        }
 
        /* store topology */
        MixerData->Topology = Topology;
    }
    else
    {
        /* re-use topology */
        Topology = MixerData->Topology;
    }
 
    /* check if the filter has an wave out node */
    NodeIndex = MMixerGetNodeIndexFromGuid(Topology, &KSNODETYPE_DAC);
    if (NodeIndex != MAXULONG)
    {
        /* it has */
        Status = MMixerInitializeFilter(MixerContext, MixerList, MixerData, NULL, Topology, NodeIndex, FALSE, &MixerInfo);
 
        /* check for success */
        if (Status == MM_STATUS_SUCCESS)
        {
            /* increment mixer count */
            (*DeviceCount)++;
        }
        else
        {
            /* reset mixer info in case of error */
            MixerInfo = NULL;
        }
    }
 
    /* check if the filter has an wave in node */
    NodeIndex = MMixerGetNodeIndexFromGuid(Topology, &KSNODETYPE_ADC);
    if (NodeIndex != MAXULONG)
    {
        /* it has */
        Status = MMixerInitializeFilter(MixerContext, MixerList, MixerData, MixerInfo, Topology, NodeIndex, TRUE, &MixerInfo);
 
        /* check for success */
        if (Status == MM_STATUS_SUCCESS)
        {
            /* increment mixer count */
            (*DeviceCount)++;
        }
 
    }
 
    /* TODO: apply hacks for Wave source line */
 
    /* activate midi devices */
    //MMixerInitializeMidiForFilter(MixerContext, MixerList, MixerData, Topology);
 
    /* done */
    return Status;
}

Referenced by MMixerInitialize().

MMixerVerifyContext()

MIXER_STATUS MMixerVerifyContext

(

IN PMIXER_CONTEXT

MixerContext

)

Definition at line 41 of file sup.c.

{
    if (MixerContext->SizeOfStruct != sizeof(MIXER_CONTEXT))
        return MM_STATUS_INVALID_PARAMETER;
 
    if (!MixerContext->Alloc || !MixerContext->Control || !MixerContext->Free || !MixerContext->Open ||
        !MixerContext->AllocEventData || !MixerContext->FreeEventData ||
        !MixerContext->Close || !MixerContext->OpenKey || !MixerContext->QueryKeyValue || !MixerContext->CloseKey)
        return MM_STATUS_INVALID_PARAMETER;
 
    if (!MixerContext->MixerContext)
        return MM_STATUS_INVALID_PARAMETER;
 
    return MM_STATUS_SUCCESS;
}

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().