session.c File Reference

#include "mmdrv.h"
#include <debug.h>

Include dependency graph for session.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
SessionInfo *	GetSession (DeviceType device_type, UINT device_id)
MMRESULT	CreateSession (DeviceType device_type, UINT device_id, SessionInfo **session_info)
VOID	DestroySession (SessionInfo *session)
MMRESULT	StartSessionThread (SessionInfo *session_info)
MMRESULT	CallSessionThread (SessionInfo *session_info, ThreadFunction function, PVOID thread_parameter)
DWORD	HandleBySessionThread (DWORD_PTR private_handle, DWORD_PTR message, DWORD_PTR parameter)

Variables
SessionInfo *	session_list = NULL
CRITICAL_SECTION	session_lock

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file session.c.

Function Documentation

CallSessionThread()

MMRESULT CallSessionThread	(	SessionInfo *	session_info,
		ThreadFunction	function,
		PVOID	thread_parameter
	)

Definition at line 219 of file session.c.

{
    ASSERT(session_info);
 
    session_info->thread.function = function;
    session_info->thread.parameter = thread_parameter;
 
    DPRINT("Calling session thread\n");
    SetEvent(session_info->thread.go_event);
 
    DPRINT("Waiting for thread response\n");
    WaitForSingleObject(session_info->thread.ready_event, INFINITE);
 
    return session_info->thread.result;
}

Referenced by CloseDevice(), HandleBySessionThread(), and WriteWaveBuffer().

CreateSession()

MMRESULT CreateSession	(	DeviceType	device_type,
		UINT	device_id,
		SessionInfo **	session_info
	)

Definition at line 63 of file session.c.

{
    HANDLE heap = GetProcessHeap();
 
    ASSERT(session_info);
 
    EnterCriticalSection(&session_lock);
 
    /* Ensure we're not creating a duplicate session */
 
    if ( GetSession(device_type, device_id) )
    {
        DPRINT("Already allocated session\n");
        LeaveCriticalSection(&session_lock);
        return MMSYSERR_ALLOCATED;
    }
 
    *session_info = HeapAlloc(heap, HEAP_ZERO_MEMORY, sizeof(SessionInfo));
 
    if ( ! *session_info )
    {
        DPRINT("Failed to allocate mem for session info\n");
        LeaveCriticalSection(&session_lock);
        return MMSYSERR_NOMEM;
    }
 
    (*session_info)->device_type = device_type;
    (*session_info)->device_id = device_id;
 
    /* Add to the list */
 
    (*session_info)->next = session_list;
    session_list = *session_info;
 
    LeaveCriticalSection(&session_lock);
 
    return MMSYSERR_NOERROR;
}

Referenced by CsrSbCreateSession(), OpenDevice(), and SmpLoadSubSystem().

DestroySession()

VOID DestroySession

(

SessionInfo *

session

)

Definition at line 113 of file session.c.

{
    HANDLE heap = GetProcessHeap();
    SessionInfo* session_node;
    SessionInfo* session_prev;
 
    /* TODO: More cleanup stuff */
 
    /* Remove from the list */
 
    EnterCriticalSection(&session_lock);
 
    session_node = session_list;
    session_prev = NULL;
 
    while ( session_node )
    {
        if ( session_node == session )
        {
            /* Bridge the gap for when we go */
            session_prev->next = session->next;
            break;
        }
 
        /* Save the previous node, fetch the next */
        session_prev = session_node;
        session_node = session_node->next;
    }
 
    LeaveCriticalSection(&session_lock);
 
    HeapFree(heap, 0, session);
}

Referenced by CloseDevice(), and OpenDevice().

GetSession()

SessionInfo * GetSession	(	DeviceType	device_type,
		UINT	device_id
	)

Definition at line 30 of file session.c.

{
    SessionInfo* session_info;
 
    EnterCriticalSection(&session_lock);
    session_info = session_list;
 
    while ( session_info )
    {
        if ( ( session_info->device_type == device_type ) &&
             ( session_info->device_id == device_id ) )
        {
            LeaveCriticalSection(&session_lock);
            return session_info;
        }
 
        session_info = session_info->next;
    }
 
    LeaveCriticalSection(&session_lock);
    return NULL;
}

Referenced by CreateSession().

HandleBySessionThread()

DWORD HandleBySessionThread	(	DWORD_PTR	private_handle,
		DWORD_PTR	message,
		DWORD_PTR	parameter
	)

Definition at line 240 of file session.c.

{
    return CallSessionThread((SessionInfo*) private_handle,
                             message,
                             (PVOID) parameter);
}

Referenced by wodMessage().

StartSessionThread()

MMRESULT StartSessionThread

(

SessionInfo *

session_info

)

Definition at line 154 of file session.c.

{
    LPTASKCALLBACK task;
    MMRESULT result;
 
    ASSERT(session_info);
 
    /* This is our "ready" event, sent when the thread is idle */
 
    session_info->thread.ready_event = CreateEvent(NULL, FALSE, FALSE, NULL);
 
    if ( ! session_info->thread.ready_event )
    {
        DPRINT("Couldn't create thread_ready event\n");
        return MMSYSERR_NOMEM;
    }
 
    /* This is our "go" event, sent when we want the thread to do something */
 
    session_info->thread.go_event = CreateEvent(NULL, FALSE, FALSE, NULL);
 
    if ( ! session_info->thread.go_event )
    {
        DPRINT("Couldn't create thread_go event\n");
        CloseHandle(session_info->thread.ready_event);
        return MMSYSERR_NOMEM;
    }
 
    /* TODO - other kinds of devices need attention, too */
    task = ( session_info->device_type == WaveOutDevice )
           ? (LPTASKCALLBACK) WaveThread : NULL;
 
    ASSERT(task);
 
    /* Effectively, this is a beefed-up CreateThread */
 
    result = mmTaskCreate(task,
                          &session_info->thread.handle,
                          (DWORD_PTR)session_info);
 
    if ( result != MMSYSERR_NOERROR )
    {
        DPRINT("Task creation failed\n");
        CloseHandle(session_info->thread.ready_event);
        CloseHandle(session_info->thread.go_event);
        return result;
    }
 
    /* Wait for the thread to be ready before completing */
 
    WaitForSingleObject(session_info->thread.ready_event, INFINITE);
 
    return MMSYSERR_NOERROR;
}

Referenced by OpenDevice().

Variable Documentation

session_list

SessionInfo* session_list = NULL

Definition at line 19 of file session.c.

Referenced by CreateSession(), DestroySession(), and GetSession().

session_lock

CRITICAL_SECTION session_lock

Definition at line 20 of file session.c.

Referenced by CreateSession(), DestroySession(), and GetSession().