pnp.c File Reference

#include "audiosrv.h"
#include <winreg.h>
#include <winuser.h>
#include <mmsystem.h>
#include <setupapi.h>
#include <ks.h>
#include <ksmedia.h>
#include <debug.h>

Include dependency graph for pnp.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
BOOL	ProcessExistingDevices (VOID)
DWORD	ProcessDeviceArrival (DEV_BROADCAST_DEVICEINTERFACE *device)
BOOL	RegisterForDeviceNotifications (VOID)
VOID	UnregisterDeviceNotifications (VOID)
DWORD	HandleDeviceEvent (DWORD dwEventType, LPVOID lpEventData)

Variables
static HDEVNOTIFY	device_notification_handle = NULL

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 17 of file pnp.c.

Function Documentation

HandleDeviceEvent()

DWORD HandleDeviceEvent	(	DWORD	dwEventType,
		LPVOID	lpEventData
	)

Definition at line 176 of file pnp.c.

{
    switch (dwEventType)
    {
        case DBT_DEVICEARRIVAL:
        {
            DEV_BROADCAST_DEVICEINTERFACE* incoming_device =
                (DEV_BROADCAST_DEVICEINTERFACE*)lpEventData;
 
            return ProcessDeviceArrival(incoming_device);
        }
 
        default :
        {
            break;
        }
    }
 
    return NO_ERROR;
}

Referenced by ServiceControlHandler().

ProcessDeviceArrival()

DWORD ProcessDeviceArrival

(

DEV_BROADCAST_DEVICEINTERFACE *

device

)

Definition at line 111 of file pnp.c.

{
    PnP_AudioDevice* list_node;
    list_node = CreateDeviceDescriptor(device->dbcc_name, TRUE);
    AppendAudioDeviceToList(list_node);
    DestroyDeviceDescriptor(list_node);
 
    return NO_ERROR;
}

Referenced by HandleDeviceEvent().

ProcessExistingDevices()

BOOL ProcessExistingDevices

(

VOID

)

Definition at line 28 of file pnp.c.

{
    SP_DEVICE_INTERFACE_DATA interface_data;
    SP_DEVINFO_DATA device_data;
    PSP_DEVICE_INTERFACE_DETAIL_DATA_W detail_data;
    HDEVINFO dev_info;
    DWORD length;
    int index = 0;
 
    const GUID category_guid = {STATIC_KSCATEGORY_AUDIO};
 
    dev_info = SetupDiGetClassDevsExW(&category_guid,
                                      NULL,
                                      NULL,
                                      DIGCF_PRESENT | DIGCF_DEVICEINTERFACE,
                                      NULL,
                                      NULL,
                                      NULL);
 
    interface_data.cbSize = sizeof(interface_data);
    interface_data.Reserved = 0;
 
    /* Enumerate the devices within the category */
    index = 0;
 
    length = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA)
                + (MAX_PATH * sizeof(WCHAR));
 
    detail_data =
        (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)HeapAlloc(GetProcessHeap(),
                                                      0,
                                                      length);
 
    if ( ! detail_data )
    {
        DPRINT("failed to allocate detail_data\n");
        return TRUE;
    }
 
    while (
    SetupDiEnumDeviceInterfaces(dev_info,
                                NULL,
                                &category_guid,
                                index,
                                &interface_data) )
    {
        PnP_AudioDevice* list_node;
 
        ZeroMemory(detail_data, length);
 
        /* NOTE: We don't actually use device_data... */
        detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
        device_data.cbSize = sizeof(device_data);
        device_data.Reserved = 0;
        SetupDiGetDeviceInterfaceDetailW(dev_info,
                                         &interface_data,
                                         detail_data,
                                         length,
                                         NULL,
                                         &device_data);
 
        list_node = CreateDeviceDescriptor(detail_data->DevicePath, TRUE);
        AppendAudioDeviceToList(list_node);
        DestroyDeviceDescriptor(list_node);
 
        /* TODO: Cleanup the device we enumerated? */
 
        index ++;
    };
 
    HeapFree(GetProcessHeap(), 0, detail_data);
 
    SetupDiDestroyDeviceInfoList(dev_info);
 
    return TRUE;
}

Referenced by ServiceMain().

RegisterForDeviceNotifications()

BOOL RegisterForDeviceNotifications

(

VOID

)

Definition at line 127 of file pnp.c.

{
    DEV_BROADCAST_DEVICEINTERFACE notification_filter;
 
    const GUID wdmaud_guid = {STATIC_KSCATEGORY_AUDIO};
 
    ZeroMemory(&notification_filter, sizeof(notification_filter));
    notification_filter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
    notification_filter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
    notification_filter.dbcc_classguid = wdmaud_guid;
 
    device_notification_handle =
        RegisterDeviceNotificationW((HANDLE) service_status_handle,
                                    &notification_filter,
                                    DEVICE_NOTIFY_SERVICE_HANDLE
/* |
                                   DEVICE_NOTIFY_ALL_INTERFACE_CLASSES*/);
    if (!device_notification_handle)
    {
        DPRINT("failed with error %d\n", GetLastError());
    }
 
    return ( device_notification_handle != NULL );
}

Referenced by ServiceMain().

UnregisterDeviceNotifications()

VOID UnregisterDeviceNotifications

(

VOID

)

Definition at line 159 of file pnp.c.

{
    /* TODO -- NOT IMPLEMENTED! */
 
    if (device_notification_handle)
    {
        /* TODO */
        device_notification_handle = NULL;
    }
}

Referenced by ServiceControlHandler(), and ServiceMain().

Variable Documentation

device_notification_handle

HDEVNOTIFY device_notification_handle = NULL

static

Definition at line 20 of file pnp.c.

Referenced by RegisterForDeviceNotifications(), and UnregisterDeviceNotifications().