devicelist.c File Reference

#include "precomp.h"

Include dependency graph for devicelist.c:

Go to the source code of this file.

Functions
ULONG	GetPinIdFromFilter (LPFILTERINFO Filter, BOOL bCapture, ULONG Offset)
DWORD	OpenDeviceList (IN LPGUID InterfaceGuid, OUT HDEVINFO *OutHandle)
BOOL	CloseDeviceList (HDEVINFO Handle)
BOOL	GetDeviceListInterfaces (HDEVINFO DeviceHandle, IN LPGUID InterfaceGuid, LPFILTERINFO *OutPath)
DWORD	OpenDeviceKey (HDEVINFO Handle, PSP_DEVINFO_DATA FILTERINFOData, DWORD KeyType, REGSAM DesiredAccess, OUT HKEY *OutKey)
VOID	FindAudioFilterPins (LPFILTERINFO CurInfo, OUT PULONG WaveInPins, OUT PULONG WaveOutPins)
BOOL	FindWinMMDeviceIndex (LPFILTERINFO CurInfo, BOOL bRecord)
HRESULT	EnumerateAudioFilter (LPFILTERINFO CurInfo, OUT PULONG WaveInCount, OUT PULONG WaveOutCount)
HRESULT	EnumAudioDeviceInterfaces (LPFILTERINFO *OutRootInfo)
BOOL	FindDeviceByMappedId (IN ULONG DeviceID, LPFILTERINFO *Filter, BOOL bPlayback)
BOOL	FindDeviceByGuid (LPCGUID pGuidSrc, LPFILTERINFO *Filter)

Function Documentation

CloseDeviceList()

BOOL CloseDeviceList

(

HDEVINFO

Handle

)

Definition at line 58 of file devicelist.c.

{
    return SetupDiDestroyDeviceInfoList(Handle);
}

Referenced by EnumAudioDeviceInterfaces().

EnumAudioDeviceInterfaces()

HRESULT EnumAudioDeviceInterfaces

(

LPFILTERINFO *

OutRootInfo

)

Definition at line 384 of file devicelist.c.

{
    HDEVINFO hList;
    DWORD Status;
    HRESULT hResult;
    ULONG WaveOutCount, WaveInCount;
    GUID AudioDeviceGuid = {STATIC_KSCATEGORY_AUDIO};
    LPFILTERINFO CurInfo;
 
    /* try open the device list */
    Status = OpenDeviceList(&AudioDeviceGuid, &hList);
 
    if (Status != ERROR_SUCCESS)
    {
        DPRINT1("OpenDeviceList failed with %lx\n", Status);
        return E_FAIL;
    }
 
    if (!GetDeviceListInterfaces(hList, &AudioDeviceGuid, OutRootInfo))
    {
        DPRINT1("No devices found\n");
        CloseDeviceList(hList);
        return S_FALSE;
    }
 
    /* sanity check */
    ASSERT(*OutRootInfo);
 
    CurInfo = *OutRootInfo;
 
    WaveOutCount = 0;
    WaveInCount = 0;
 
    /* now check all audio filters */
    while(CurInfo)
    {
        /* now check details of the audio filter */
        hResult = EnumerateAudioFilter(CurInfo, &WaveInCount, &WaveOutCount);
 
        if (hResult != S_OK)
        {
           DPRINT1("EnumerateAudioFilter failed with %lx\n", Status);
           break;
        }
 
        /* move to next filter */
        CurInfo = CurInfo->lpNext;
    }
 
    /* close device list */
    CloseDeviceList(hList);
 
    /* done */
    return hResult;
}

Referenced by DllMain(), DSoundEnumerate(), and IDirectSound8_fnInitialize().

EnumerateAudioFilter()

HRESULT EnumerateAudioFilter	(	LPFILTERINFO	CurInfo,
		OUT PULONG	WaveInCount,
		OUT PULONG	WaveOutCount
	)

Definition at line 315 of file devicelist.c.

{
    DWORD Status;
    ULONG PinCount, WaveInPins, WaveOutPins;
 
    /* first step open filter */
    Status = OpenFilter((LPCWSTR)CurInfo->DevicePath, &CurInfo->hFilter);
    if (Status != ERROR_SUCCESS)
    {
        DPRINT("Failed to open filter with %lx Path %ws\n", Status, CurInfo->DevicePath);
        return E_FAIL;
    }
 
    /* get filter pin count */
    Status = GetFilterPinCount(CurInfo->hFilter, &PinCount);
    if (Status != ERROR_SUCCESS)
    {
        DPRINT("Failed to get pin count with %lx\n", Status);
        return E_FAIL;
    }
 
    /* sanity check */
    ASSERT(PinCount);
 
    /* store pin count */
    CurInfo->PinCount = PinCount;
 
    /* now allocate an pin array */
    CurInfo->Pin = HeapAlloc(GetProcessHeap(), 0, PinCount * sizeof(ULONG));
    if (!CurInfo->Pin)
    {
        /* no memory */
        return E_FAIL;
    }
 
    /* no try to find playback / recording pins */
    FindAudioFilterPins(CurInfo, &WaveInPins, &WaveOutPins);
 
    DPRINT("WaveInPins %u WaveOutPins %u %S\n", WaveInPins, WaveOutPins, CurInfo->DevicePath);
 
    if (WaveOutPins)
    {
        /* create a unique guid for this playback device */
        if (FindWinMMDeviceIndex(CurInfo, TRUE))
        {
            (*WaveOutCount)++;
            INIT_GUID(CurInfo->DeviceGuid[0], 0xbd6dd71a, 0x3deb, 0x11d1, 0xb1, 0x71, 0x00, 0xc0, 0x4f, 0xc2, 0x00, 0x00 + *WaveInCount);
        }
    }
 
 
    if (WaveInPins)
    {
        if (FindWinMMDeviceIndex(CurInfo, FALSE))
        {
            /* create a unique guid for this record device */
            (*WaveInCount)++;
            INIT_GUID(CurInfo->DeviceGuid[1], 0xbd6dd71b, 0x3deb, 0x11d1, 0xb1, 0x71, 0x00, 0xc0, 0x4f, 0xc2, 0x00, 0x00 + *WaveOutCount);
        }
    }
 
    return S_OK;
}

Referenced by EnumAudioDeviceInterfaces().

FindAudioFilterPins()

VOID FindAudioFilterPins	(	LPFILTERINFO	CurInfo,
		OUT PULONG	WaveInPins,
		OUT PULONG	WaveOutPins
	)

Definition at line 199 of file devicelist.c.

{
    ULONG Index;
    KSPIN_COMMUNICATION Communication;
    KSPIN_DATAFLOW DataFlow;
 
    *WaveInPins = 0;
    *WaveOutPins = 0;
 
    /* traverse all pins */
    for(Index = 0; Index < CurInfo->PinCount; Index++)
    {
        if (GetFilterPinCommunication(CurInfo->hFilter, Index, &Communication) == ERROR_SUCCESS &&
            GetFilterPinDataFlow(CurInfo->hFilter, Index, &DataFlow) == ERROR_SUCCESS)
        {
            if (Communication == KSPIN_COMMUNICATION_SINK && DataFlow == KSPIN_DATAFLOW_IN)
            {
                /* found a wave out device */
                CurInfo->Pin[Index] = PIN_TYPE_PLAYBACK;
                (*WaveOutPins)++;
            }
            else if (Communication == KSPIN_COMMUNICATION_SINK && DataFlow == KSPIN_DATAFLOW_OUT)
            {
                /* found a wave in device */
                CurInfo->Pin[Index] = PIN_TYPE_RECORDING;
                (*WaveInPins)++;
            }
            else
            {
                /* bridge pin / topology pin etc */
                CurInfo->Pin[Index] = PIN_TYPE_NONE;
            }
        }
        else
        {
            /* bridge pin / topology pin etc */
            CurInfo->Pin[Index] = PIN_TYPE_NONE;
        }
    }
}

Referenced by EnumerateAudioFilter().

FindDeviceByGuid()

BOOL FindDeviceByGuid	(	LPCGUID	pGuidSrc,
		LPFILTERINFO *	Filter
	)

Definition at line 470 of file devicelist.c.

{
    LPFILTERINFO CurInfo;
    if (!RootInfo)
        return FALSE;
 
    /* get first entry */
    CurInfo = RootInfo;
 
    while(CurInfo)
    {
        if (IsEqualGUID(&CurInfo->DeviceGuid[0], pGuidSrc) ||
            IsEqualGUID(&CurInfo->DeviceGuid[1], pGuidSrc))
        {
            /* found filter */
            *Filter = CurInfo;
            return TRUE;
        }
 
        CurInfo = CurInfo->lpNext;
    }
 
    return FALSE;
}

Referenced by CDirectSoundCapture_fnInitialize(), GetDeviceID(), IDirectSound8_fnInitialize(), and KSPropertySetImpl_Get().

FindDeviceByMappedId()

BOOL FindDeviceByMappedId	(	IN ULONG	DeviceID,
		LPFILTERINFO *	Filter,
		BOOL	bPlayback
	)

Definition at line 442 of file devicelist.c.

{
    LPFILTERINFO CurInfo;
    if (!RootInfo)
        return FALSE;
 
    /* get first entry */
    CurInfo = RootInfo;
 
    while(CurInfo)
    {
        if ((bPlayback && CurInfo->MappedId[1] == DeviceID) ||
            (!bPlayback && CurInfo->MappedId[0] == DeviceID))
        {
            /* found filter */
            *Filter = CurInfo;
            return TRUE;
        }
 
        CurInfo = CurInfo->lpNext;
    }
    return FALSE;
}

Referenced by GetDeviceID().

FindWinMMDeviceIndex()

BOOL FindWinMMDeviceIndex	(	LPFILTERINFO	CurInfo,
		BOOL	bRecord
	)

Definition at line 244 of file devicelist.c.

{
    ULONG DeviceCount, Index;
    WCHAR Buffer[MAX_PATH];
    DWORD Size, dwResult;
 
    if (bRecord)
        DeviceCount = waveInGetNumDevs();
    else
        DeviceCount = waveOutGetNumDevs();
 
    /* sanity check */
    //ASSERT(DeviceCount);
 
    for(Index = 0; Index < DeviceCount; Index++)
    {
        Size = 0;
 
        /* query device interface size */
        if (bRecord)
            dwResult = waveInMessage(UlongToHandle(Index), DRV_QUERYDEVICEINTERFACESIZE, (DWORD_PTR)&Size, 0);
        else
            dwResult = waveOutMessage(UlongToHandle(Index), DRV_QUERYDEVICEINTERFACESIZE, (DWORD_PTR)&Size, 0);
 
        if (dwResult != MMSYSERR_NOERROR)
        {
            DPRINT("Failed DRV_QUERYDEVICEINTERFACESIZE with %lx bRecord %u Index %u\n", dwResult, bRecord, Index);
            continue;
        }
 
        /* sanity check */
        ASSERT(Size < MAX_PATH);
 
        /* now get the device interface string */
        if (bRecord)
            dwResult = waveInMessage(UlongToHandle(Index), DRV_QUERYDEVICEINTERFACE, (DWORD_PTR)Buffer, MAX_PATH);
        else
            dwResult = waveOutMessage(UlongToHandle(Index), DRV_QUERYDEVICEINTERFACE, (DWORD_PTR)Buffer, MAX_PATH);
 
        if (dwResult != MMSYSERR_NOERROR)
        {
            DPRINT("Failed DRV_QUERYDEVICEINTERFACE with %lx bRecord %u Index %u\n", dwResult, bRecord, Index);
            continue;
        }
 
        if (!wcsicmp(CurInfo->DevicePath, Buffer))
        {
            if (bRecord)
                CurInfo->MappedId[0] = Index;
            else
                CurInfo->MappedId[1] = Index;
 
            return TRUE;
        }
    }
 
    DPRINT1("Failed to find device %ws bRecord %u Count %u\n", CurInfo->DevicePath, bRecord, DeviceCount);
 
    // HACK
    if (bRecord)
        CurInfo->MappedId[0] = 0;
    else
        CurInfo->MappedId[1] = 0;
 
 
    return TRUE;
}

Referenced by EnumerateAudioFilter().

GetDeviceListInterfaces()

BOOL GetDeviceListInterfaces	(	HDEVINFO	DeviceHandle,
		IN LPGUID	InterfaceGuid,
		LPFILTERINFO *	OutPath
	)

Definition at line 65 of file devicelist.c.

{
    ULONG Length, Index = 0;
    SP_DEVICE_INTERFACE_DATA InterfaceData;
    PSP_DEVICE_INTERFACE_DETAIL_DATA_W DetailData;
    SP_DEVINFO_DATA DeviceData;
    LPFILTERINFO LastDevice = NULL, RootDevice = NULL, CurDevice;
    BOOL Result;
 
 
    do
    {
        InterfaceData.cbSize = sizeof(InterfaceData);
        InterfaceData.Reserved = 0;
 
        /* query device interface */
        Result = SetupDiEnumDeviceInterfaces(DeviceHandle,
                                NULL,
                                InterfaceGuid,
                                Index,
                                &InterfaceData);
 
        if (!Result)
        {
            /* failed */
            DPRINT("SetupDiEnumDeviceInterfaces Index %u failed with %lx\n", Index, GetLastError());
            break;
        }
 
        /* allocate device interface struct */
        Length = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W) + MAX_PATH * sizeof(WCHAR);
        DetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)HeapAlloc(GetProcessHeap(),
                                                                 HEAP_ZERO_MEMORY,
                                                                 Length);
 
        if (!DetailData)
        {
            /* insufficient memory */
            break;
        }
 
        /* initialize device interface detail struct */
        DetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
 
        DeviceData.cbSize = sizeof(DeviceData);
        DeviceData.Reserved = 0;
 
        Result = SetupDiGetDeviceInterfaceDetailW(DeviceHandle,
                                                  &InterfaceData,
                                                  DetailData,
                                                  Length,
                                                  NULL,
                                                  &DeviceData);
 
       if (!Result)
       {
           /* failed */
           DPRINT("SetupDiGetDeviceInterfaceDetail failed with %x\n", GetLastError());
           HeapFree(GetProcessHeap(), 0, DetailData);
 
           break;
       }
 
       /* allocate device path struct */
       CurDevice = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FILTERINFO));
       if (!CurDevice)
       {
           /* no memory */
           HeapFree(GetProcessHeap(), 0, DetailData);
           break;
       }
 
       /* store device path */
       CopyMemory(&CurDevice->DeviceData, &DeviceData, sizeof(SP_DEVINFO_DATA));
       wcscpy(CurDevice->DevicePath, DetailData->DevicePath);
       CurDevice->MappedId[0] = ULONG_MAX;
       CurDevice->MappedId[1] = ULONG_MAX;
 
       DPRINT("DevicePath %S\n", CurDevice->DevicePath);
 
       if (!RootDevice)
           RootDevice = CurDevice;
 
       if (LastDevice)
       {
           LastDevice->lpNext = CurDevice;
       }
 
       /* set as last device */
       LastDevice = CurDevice;
 
        /* free device interface struct */
        HeapFree(GetProcessHeap(), 0, DetailData);
 
       /* increment device interface index */
       Index++;
    }while(TRUE);
 
    /* store result */
    *OutPath = RootDevice;
 
    if (!RootDevice)
        return FALSE;
 
 
    return TRUE;
}

Referenced by EnumAudioDeviceInterfaces().

GetPinIdFromFilter()

ULONG GetPinIdFromFilter	(	LPFILTERINFO	Filter,
		BOOL	bCapture,
		ULONG	Offset
	)

Definition at line 13 of file devicelist.c.

{
    ULONG Index;
 
    for(Index = Offset; Index < Filter->PinCount; Index++)
    {
        if (Filter->Pin[Index] == PIN_TYPE_PLAYBACK && !bCapture)
            return Index;
 
        if (Filter->Pin[Index] == PIN_TYPE_RECORDING && bCapture)
            return Index;
    }
    return ULONG_MAX;
}

Referenced by NewDirectSoundCaptureBuffer(), and PrimaryDirectSoundBuffer_SetFormat().

OpenDeviceKey()

DWORD OpenDeviceKey	(	HDEVINFO	Handle,
		PSP_DEVINFO_DATA	FILTERINFOData,
		DWORD	KeyType,
		REGSAM	DesiredAccess,
		OUT HKEY *	OutKey
	)

Definition at line 177 of file devicelist.c.

{
    HKEY hKey;
 
    /* try open device registry key */
    hKey = SetupDiOpenDevRegKey(Handle, FILTERINFOData, DICS_FLAG_CONFIGSPECIFIC, 0, KeyType, DesiredAccess);
 
    if (hKey == INVALID_HANDLE_VALUE)
        return GetLastError();
 
    /* store result */
    *OutKey = hKey;
 
    return ERROR_SUCCESS;
}

OpenDeviceList()

DWORD OpenDeviceList	(	IN LPGUID	InterfaceGuid,
		OUT HDEVINFO *	OutHandle
	)

Definition at line 33 of file devicelist.c.

{
    HDEVINFO DeviceHandle;
 
    DeviceHandle = SetupDiGetClassDevs(InterfaceGuid,
                                       NULL,
                                       NULL,
                                       DIGCF_DEVICEINTERFACE); //DIGCF_PRESENT
 
    /* check for success */
    if (DeviceHandle == INVALID_HANDLE_VALUE)
    {
        /* failed to create device list */
        return GetLastError();
    }
 
    /* store result */
    *OutHandle = DeviceHandle;
 
    return ERROR_SUCCESS;
}

Referenced by EnumAudioDeviceInterfaces().