audiosrv.h File Reference

#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <malloc.h>
#include <dbt.h>
#include <audiosrv/audiosrv.h>

Include dependency graph for audiosrv.h:

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

Go to the source code of this file.

Macros
#define	AUDIOSRV_PRIVATE_H
#define	DestroyDeviceDescriptor(descriptor)   free(descriptor)

Functions
VOID *	CreateDeviceDescriptor (WCHAR *path, BOOL is_enabled)
BOOL	AppendAudioDeviceToList (PnP_AudioDevice *device)
BOOL	CreateAudioDeviceList (DWORD max_size)
VOID	DestroyAudioDeviceList (VOID)
BOOL	ProcessExistingDevices (VOID)
DWORD	ProcessDeviceArrival (DEV_BROADCAST_DEVICEINTERFACE *device)
BOOL	RegisterForDeviceNotifications (VOID)
VOID	UnregisterDeviceNotifications (VOID)
DWORD	HandleDeviceEvent (DWORD dwEventType, LPVOID lpEventData)
BOOL	StartSystemAudioServices (VOID)

Variables
SERVICE_STATUS_HANDLE	service_status_handle

Macro Definition Documentation

AUDIOSRV_PRIVATE_H

#define AUDIOSRV_PRIVATE_H

Definition at line 20 of file audiosrv.h.

DestroyDeviceDescriptor

#define DestroyDeviceDescriptor

(

descriptor

)

free(descriptor)

Definition at line 30 of file audiosrv.h.

Function Documentation

AppendAudioDeviceToList()

BOOL AppendAudioDeviceToList

(

PnP_AudioDevice *

device

)

Definition at line 57 of file pnp_list_manager.c.

{
    int device_info_size;
 
    /* Figure out the actual structure size */
    device_info_size = sizeof(PnP_AudioDevice);
    device_info_size += WideStringSize(device->path);
 
    LockAudioDeviceList();
 
    /* We DON'T want to overshoot the end of the buffer! */
    if (audio_device_list->size + device_info_size > audio_device_list->max_size)
    {
        /*DPRINT("failed, max_size would be exceeded\n");*/
 
        UnlockAudioDeviceList();
 
        return FALSE;
    }
 
    /* Commit the device descriptor to the list */
    memcpy((char*)audio_device_list + audio_device_list->size,
           device,
           device_info_size);
 
    /* Update the header */
    audio_device_list->device_count ++;
    audio_device_list->size += device_info_size;
 
    UnlockAudioDeviceList();
 
    DPRINT("Device added to list\n");
 
    return TRUE;
}

Referenced by InitializeFakeDevice(), ProcessDeviceArrival(), and ProcessExistingDevices().

CreateAudioDeviceList()

BOOL CreateAudioDeviceList

(

DWORD

max_size

)

Definition at line 94 of file pnp_list_manager.c.

{
    if (!InitializeAudioDeviceListLock())
    {
        /*DPRINT("Failed\n");*/
        return FALSE;
    }
 
    /* Preliminary locking - the list memory will likely be a big
       buffer of gibberish at this point so we don't want anyone
       turning up before we're ready... */
    LockAudioDeviceList();
 
    DPRINT("Creating file mapping\n");
    /* Expose our device list to the world */
    device_list_file = CreateFileMappingW(INVALID_HANDLE_VALUE,
                                          NULL,
                                          PAGE_READWRITE,
                                          0,
                                          max_size,
                                          AUDIO_LIST_NAME);
    if (!device_list_file)
    {
        DPRINT("Creation of audio device list failed (err %d)\n", GetLastError());
 
        UnlockAudioDeviceList();
        KillAudioDeviceListLock();
 
        return FALSE;
    }
 
    DPRINT("Mapping view of file\n");
    /* Of course, we'll need to access the list ourselves */
    audio_device_list = MapViewOfFile(device_list_file,
                                      FILE_MAP_WRITE,
                                      0,
                                      0,
                                      max_size);
    if (!audio_device_list)
    {
        DPRINT("MapViewOfFile FAILED (err %d)\n", GetLastError());
 
        CloseHandle(device_list_file);
        device_list_file = NULL;
 
        UnlockAudioDeviceList();
        KillAudioDeviceListLock();
 
        return FALSE;
    }
 
    /* Clear the mem to avoid any random stray data */
    memset(audio_device_list, 0, max_size);
 
    /* Don't want devices to overwrite the list! */
    audio_device_list->size = sizeof(PnP_AudioHeader);
    audio_device_list->max_size = max_size;
    audio_device_list->device_count = 0;
 
    UnlockAudioDeviceList();
 
    DPRINT("Device list created\n");
 
    return TRUE;
}

Referenced by ServiceMain().

CreateDeviceDescriptor()

VOID * CreateDeviceDescriptor	(	WCHAR *	path,
		BOOL	is_enabled
	)

Definition at line 18 of file pnp_list_manager.c.

{
    PnP_AudioDevice* device;
 
    int path_length = WideStringSize(path);
    int size = sizeof(PnP_AudioDevice) + path_length;
 
    device = malloc(size);
    if (! device)
    {
        DPRINT("Failed to malloc device descriptor\n");
        return NULL;
    }
 
    device->enabled = is_enabled;
    memcpy(device->path, path, path_length);
 
    return device;
}

Referenced by InitializeFakeDevice(), ProcessDeviceArrival(), and ProcessExistingDevices().

DestroyAudioDeviceList()

VOID DestroyAudioDeviceList

(

VOID

)

Definition at line 161 of file pnp_list_manager.c.

{
    DPRINT("Destroying device list\n");
 
    LockAudioDeviceList();
 
    /*DPRINT("Unmapping view\n");*/
    UnmapViewOfFile(audio_device_list);
    audio_device_list = NULL;
 
    /*DPRINT("Closing memory mapped file\n");*/
    CloseHandle(device_list_file);
    device_list_file = NULL;
 
    UnlockAudioDeviceList();
 
    /*DPRINT("Killing devlist lock\n");*/
    KillAudioDeviceListLock();
}

Referenced by ServiceControlHandler(), and ServiceMain().

HandleDeviceEvent()

DWORD HandleDeviceEvent	(	DWORD	dwEventType,
		LPVOID	lpEventData
	)

Definition at line 192 of file pnp.c.

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

Referenced by ServiceControlHandler().

ProcessDeviceArrival()

DWORD ProcessDeviceArrival

(

DEV_BROADCAST_DEVICEINTERFACE *

device

)

Definition at line 118 of file pnp.c.

{
    PnP_AudioDevice* list_node;
    list_node = CreateDeviceDescriptor(device->dbcc_name, TRUE);
    AppendAudioDeviceToList(list_node);
    DestroyDeviceDescriptor(list_node);
 
    DWORD dwInfo = BSM_ALLDESKTOPS | BSM_APPLICATIONS;
    BroadcastSystemMessageW(BSF_POSTMESSAGE, &dwInfo, uWinMMDeviceChange, 0, 0);
 
    return NO_ERROR;
}

Referenced by HandleDeviceEvent().

ProcessExistingDevices()

BOOL ProcessExistingDevices

(

VOID

)

Definition at line 30 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);
 
    uWinMMDeviceChange = RegisterWindowMessageW(L"winmm_devicechange");
 
    if (uWinMMDeviceChange == 0)
        DPRINT1("Failed to register winmm_devicechange window message: GetLastError %u\n", GetLastError());
 
    return TRUE;
}

Referenced by ServiceMain().

RegisterForDeviceNotifications()

BOOL RegisterForDeviceNotifications

(

VOID

)

Definition at line 147 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);
    if (!device_notification_handle)
    {
        DPRINT("failed with error %d\n", GetLastError());
    }
 
    return ( device_notification_handle != NULL );
}

Referenced by ServiceMain().

StartSystemAudioServices()

BOOL StartSystemAudioServices

(

VOID

)

Definition at line 72 of file services.c.

{
    SC_HANDLE hSCManager;
 
    DPRINT("Starting system audio services\n");
 
    hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
    if (!hSCManager)
    {
        DPRINT("Failed to open service manager %x\n", GetLastError());
        return FALSE;
    }
 
    DPRINT("Starting sysaudio service\n");
    StartAudioService(hSCManager, L"sysaudio", 20);
    DPRINT("Starting wdmaud service\n");
    StartAudioService(hSCManager, L"wdmaud", 20);
 
    CloseServiceHandle(hSCManager);
    return TRUE;
}

Referenced by ServiceMain().

UnregisterDeviceNotifications()

VOID UnregisterDeviceNotifications

(

VOID

)

Definition at line 177 of file pnp.c.

{
    if (device_notification_handle)
    {
        if (UnregisterDeviceNotification(device_notification_handle))
            device_notification_handle = NULL;
    }
}

Referenced by ServiceControlHandler(), and ServiceMain().

Variable Documentation

service_status_handle

SERVICE_STATUS_HANDLE service_status_handle

extern

Definition at line 13 of file main.c.

Referenced by RegisterForDeviceNotifications(), ServiceControlHandler(), and ServiceMain().