wavmain.cpp

此代码为WCE5.0下声卡的源代码

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
// -----------------------------------------------------------------------------
//
//      THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
//      ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
//      THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//      PARTICULAR PURPOSE.
//  
// -----------------------------------------------------------------------------

#define INSTANTIATE_DEBUG
#include <wavdrv.h>


// -----------------------------------------------------------------------------
// DllMain
// -----------------------------------------------------------------------------
BOOL __stdcall
DllMain (
    HANDLE  hinstDLL,
    DWORD   Op,
    LPVOID  lpvReserved
    )
{
    switch (Op) {

        case DLL_PROCESS_ATTACH :
            DEBUGREGISTER((HINSTANCE)hinstDLL);
	    DisableThreadLibraryCalls((HMODULE) hinstDLL);
            break;

        case DLL_PROCESS_DETACH :
            break;
            
        case DLL_THREAD_DETACH :
            break;
            
        case DLL_THREAD_ATTACH :
            break;
            
        default :
            break;
    }
    return TRUE;
}


// OPENHANDLES are created on WAV_Open and get passed in to WAV_IoControl, WAV_Write, etc.
typedef struct _tag_OPENHANDLE
{
    HDRIVER hDriver;
    DWORD   dwTrust; // for tracking trust level of owning process
} OPENHANDLE, *POPENHANDLE;

// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
EXTERN_C HDRIVER
WAV_Init(
    PCTSTR pszActiveKey
    )
{ HDRIVER pDriver;

    DEBUGMSG (ZONE_DRIVER, (TEXT("WAV_Init(%s)\r\n"), pszActiveKey));
    
    CalibrateStallCounter();

    pDriver = new CDriverContext();
    if (pDriver != NULL) {
        if (! pDriver->Initialize(pszActiveKey)) {
            DEBUGMSG(ZONE_ERROR, (TEXT("WAV_Init FAILED")));
            delete pDriver;
            pDriver = NULL;
        }
    }
    return pDriver;
}

// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
EXTERN_C BOOL
WAV_Deinit(
    HDRIVER pDriver
    )
{
    DEBUGMSG (ZONE_DRIVER, (TEXT("WAV_Deinit(0x%X)\r\n"), pDriver));
    delete pDriver;
    return TRUE;
}

// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
EXTERN_C VOID
WAV_PowerUp(
    HDRIVER pDriver
    )
{
    DEBUGMSG (ZONE_DRIVER, (TEXT("WAV_PowerUp(%08x)\r\n"), pDriver));
    pDriver->PowerUp();
}



// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
EXTERN_C VOID
WAV_PowerDown(
    HDRIVER pDriver
    )
{
    DEBUGMSG (ZONE_DRIVER, (TEXT("WAV_PowerDown(%08x)\r\n"), pDriver));
    pDriver->PowerDown();
}


// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
EXTERN_C POPENHANDLE
WAV_Open(
    HDRIVER pDriver, 
    DWORD dwAccess, 
    DWORD dwShareMode
    )
{ POPENHANDLE pHandle;

    DEBUGMSG (ZONE_DRIVER, (TEXT("WAV_Open(0x%X)\r\n"), pDriver));
    pHandle = new OPENHANDLE;
    if (pHandle != NULL) {
        pHandle->hDriver = pDriver;
        pHandle->dwTrust = NULL; // assume untrusted. can't tell for sure until WAV_IoControl
    }
    return pHandle;
}



// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
EXTERN_C BOOL
WAV_Close(
    POPENHANDLE pOpenHandle
    )
{
    DEBUGMSG (ZONE_DRIVER, (TEXT("WAV_Close(0x%X)\r\n"), pOpenHandle));
    LocalFree(pOpenHandle);
    return TRUE;
}



// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
EXTERN_C DWORD
WAV_Read(
    POPENHANDLE pOpenHandle,
    LPVOID pBuf, 
    DWORD Len
    )
{
    DEBUGMSG (ZONE_DRIVER, (TEXT("WAV_Read(0x%X, 0x%X, %d)\r\n"), pOpenHandle, pBuf, Len));

    // Return length read
    return 0;
}




// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
EXTERN_C DWORD
WAV_Write(
    POPENHANDLE pOpenHandle,
    LPCVOID pBuf, 
    DWORD Len
    )
{
    DEBUGMSG (ZONE_DRIVER, (TEXT("WAV_Write(0x%X, 0x%X, %d)\r\n"), pOpenHandle, pBuf, Len));

    // return number of bytes written (or -1 for error)
    return 0;
}



// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
EXTERN_C DWORD
WAV_Seek(
    POPENHANDLE pOpenHandle,
    long pos, 
    DWORD type
    )
{
    DEBUGMSG (ZONE_DRIVER, (TEXT("WAV_Seek(0x%X, %d, %d)\r\n"), pOpenHandle,pos, type));

    // return an error
    return (DWORD)-1;
}


// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
EXTERN_C BOOL
WAV_IOControl(
    POPENHANDLE pOpenHandle, 
    DWORD  dwCode, 
    PVOID pBufIn,
    DWORD  dwLenIn, 
    PDWORD  pdwBufOut, 
    DWORD  dwLenOut,
    PDWORD pdwActualOut
    )
{ DWORD dwResult;

    // check caller trust. if context hasn't been initialized, load from CeGetCallerTrust.
    if (pOpenHandle->dwTrust != OEM_CERTIFY_TRUST) {
        if (OEM_CERTIFY_TRUST != (pOpenHandle->dwTrust = CeGetCallerTrust())) {
            DEBUGMSG(ZONE_ERROR, (TEXT("WAV_IoControl: untrusted process\r\n")));
            SetLastError(ERROR_ACCESS_DENIED);
            return FALSE;
        }
    }

    switch (dwCode) {
    case IOCTL_WAV_MESSAGE:         
    case IOCTL_MIX_MESSAGE:
        // fall through and handle the message
        break;
    default:
        // Unrecognized IOCTL
        return FALSE;
    }

    // make sure we can send back the return code
    if (dwLenOut < sizeof(DWORD) || pdwBufOut == NULL) {
        SetLastError (MMSYSERR_INVALPARAM);
        return FALSE;
    }

    HDRIVER pDriver = pOpenHandle->hDriver;

    switch (dwCode) {
    case IOCTL_WAV_MESSAGE:         
        dwResult = pDriver->WaveMessage((PMMDRV_MESSAGE_PARAMS) pBufIn);
        break;

    case IOCTL_MIX_MESSAGE:
        dwResult = pDriver->MixerMessage((PMMDRV_MESSAGE_PARAMS) pBufIn);
        break;
    }


    *pdwBufOut = dwResult;
     if (pdwActualOut != NULL) {
         *pdwActualOut = sizeof(DWORD);
     }

     return TRUE;
}