wav.cpp

CIRRUS 93XX系列windows mobile 6.0 BSP

//
//  @comm   Called to suspend device.  Cannot call any routines aside from
//          those in the dll in this call.
//
// -----------------------------------------------------------------------------
extern "C" VOID WAV_PowerDown( VOID )
{
	AudioDriver * pAudio=g_pAudioDriverHead;

	for(; pAudio; ) 
	{
		pAudio->PowerDown( );
		pAudio=pAudio->pNext;
	}
    //WMDD_PowerHandler(TRUE);
}

// -----------------------------------------------------------------------------
//
//  @doc    WDEV_EXT
//
//  @func   BOOL | WAV_IOControl | Device IO control routine
//
//  @parm   DWORD | dwOpenData | Value returned from WAV_Open call
//
//  @parm   DWORD | dwCode | 
//          IO control code for the function to be performed. WAV_IOControl only
//          supports one IOCTL value (IOCTL_WAV_MESSAGE)
//
//  @parm   PBYTE | pBufIn | 
//          Pointer to the input parameter structure (<t MMDRV_MESSAGE_PARAMS>).
//
//  @parm   DWORD | dwLenIn | 
//          Size in bytes of input parameter structure (sizeof(<t MMDRV_MESSAGE_PARAMS>)).
//
//  @parm   PBYTE | pBufOut | Pointer to the return value (DWORD).
//
//  @parm   DWORD | dwLenOut | Size of the return value variable (sizeof(DWORD)).
//
//  @parm   PDWORD | pdwActualOut | Unused
//
//  @rdesc  Returns TRUE for success, FALSE for failure
//
//  @xref   <t Wave Input Driver Messages> (WIDM_XXX) <nl>
//          <t Wave Output Driver Messages> (WODM_XXX)
//
// -----------------------------------------------------------------------------
extern "C" BOOL WAV_IOControl
(
    DWORD  dwOpenData, 
    DWORD  dwCode, 
    PBYTE  pBufIn,
    DWORD  dwLenIn, 
    PBYTE  pBufOut, 
    DWORD  dwLenOut,
    PDWORD pdwActualOut
)
{
    DWORD dwRet;
    PMMDRV_MESSAGE_PARAMS pParams = (PMMDRV_MESSAGE_PARAMS) pBufIn;
    AudioDriver *pAudioDrv;    


    //  set the error code to be no error first
    SetLastError(MMSYSERR_NOERROR);

    __try 
    {
        pAudioDrv = *(AudioDriver **)dwOpenData;

		switch( dwCode )
		{
        case IOCTL_WAV_MESSAGE:

            dwRet = pAudioDrv->WaveMessage((PMMDRV_MESSAGE_PARAMS) pBufIn);

		break;

        case IOCTL_MIX_MESSAGE:

			dwRet = pAudioDrv->MixerMessage((PMMDRV_MESSAGE_PARAMS) pBufIn);
		break;

		case IOCTL_DSHAL_MESSAGE:
			RETAILMSG(1, (TEXT("Unsupported dwCode IOCTL_DSHAL_MESSAGE in WAV_IOControl()\r\n")));
			return FALSE;
		default:
            RETAILMSG(1, (TEXT("Unsupported dwCode = 0x%08x in WAV_IOControl()\r\n"),dwCode));
            return(FALSE);
		}
        //
        // Pass the return code back via pBufOut
        //
        if (pBufOut != NULL) 
        {
            *((DWORD*) pBufOut) = dwRet;
        }   
    } __except (GetExceptionCode() == STATUS_ACCESS_VIOLATION ?
            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) 
    {

        RETAILMSG(1, (TEXT("EXCEPTION IN WAV_IOControl!!!!\r\n")));
    }   

    return TRUE;
}

void AudioDriver::PowerDown( void )
{
	if( m_pCodec == &m_I2S )
	{//I2S
		m_WaveOut.PowerDown( );
		m_bPowerDown=TRUE;
	}
}

void AudioDriver::PowerUp( void )
{
	if( m_pCodec == &m_I2S )
	{//I2S
		m_WaveOut.PowerUp( );
	}
}


//****************************************************************************
// AudioDriver::Initialize
//****************************************************************************
// Audio Driver Initialation routine.
// 
//

MMRESULT AudioDriver::Initialize(void)
{
    BOOL    bUseAC97;
    BOOL    bUsePIO;

    HKEY    hKey;
    DWORD   dwRet;

    //
    // Open the WaveDev driver key.
    //
    RegOpenKeyEx
    ( 
        HKEY_LOCAL_MACHINE,
        TEXT("\\Drivers\\BuiltIn\\WaveDev"),
        0,
        0,
        &hKey
    ); 


    //
    // Check to see if we are using I2S or AC97.
    //
    bUseAC97  = ReadRegistryValue(hKey, TEXT("UseAC97"), 0);
    //
    // Check to see if we are using PIO for the 
    //
    bUsePIO   = ReadRegistryValue(hKey, TEXT("UsePIO"), 0);
     //
    // Close the registry key.
    //
    RegCloseKey( hKey);


    //
    // Initializes the proper codec type
    //
    if(bUseAC97)
    {
        //
        // Initialize the AC97 codec
        //
        dwRet = m_AC97.Initialize();
        if(MMSUCCESS(dwRet))
        {
            m_pCodec = &m_AC97;
        }        
        if(!MMSUCCESS(dwRet))
        {
            ERRORMSG(ZONE_ERROR, (L"AudioDriver::Initialize: Failed to initialize AC97Codec\n" )) ;
        }
    }
    else
    {
        // Initialize the I2S mixer
        //
        dwRet = m_I2S.Initialize();
        if(MMSUCCESS(dwRet))
        {
            m_pCodec = &m_I2S;
        }        
        if(!MMSUCCESS(dwRet))
        {
            ERRORMSG(ZONE_ERROR, (L"AudioDriver::Initialize: Failed to initialize I2S Codec\n" )) ;
        }

    }

    //
    // Initialize the Waveout class.
    //    
    if(MMSUCCESS(dwRet))
    {
        dwRet = m_WaveOut.Initialize(m_pCodec, bUsePIO);
        if(!MMSUCCESS(dwRet))
        {
            ERRORMSG(ZONE_ERROR, (L"AudioDriver::Initialize: Failed to initialize gpWaveOut\n" )) ;
        }
    }        
    
    //
    // Initialize the Wavein class.
    //    
    if(MMSUCCESS(dwRet))
    {
        dwRet = m_WaveIn.Initialize(m_pCodec, bUsePIO);
        if(!MMSUCCESS(dwRet))
        {
            ERRORMSG(ZONE_ERROR, (L"AudioDriver::Initialize: Failed to initialize gpWaveIn\n" )) ;
        }
    }        
    
    
    return dwRet;
}

//****************************************************************************
// AudioDriver::WaveMessage
//****************************************************************************
// Process all wavein/out messages.
// 
//
DWORD AudioDriver::WaveMessage(PMMDRV_MESSAGE_PARAMS pParams)
{
    DWORD   dwRet;

    switch (pParams->uMsg) 
    {

        case WODM_BREAKLOOP:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_BREAKLOOP\r\n")));
            dwRet = m_WaveOut.BreakLoop();
            break;

        case WODM_CLOSE:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_CLOSE\r\n")));
            dwRet = m_WaveOut.Close();
            break;

        case WODM_GETDEVCAPS:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_GETDEVCAPS\r\n")));
            dwRet = m_WaveOut.GetDevCaps((PWAVEOUTCAPS) pParams->dwParam1, pParams->dwParam2);
            break;

        case WODM_GETNUMDEVS:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_GETNUMDEVS\r\n")));
            dwRet = m_WaveOut.GetNumDev();
            break;

        case WODM_GETPITCH:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_GETPITCH\r\n")));
            dwRet = m_WaveOut.GetPitch();
            break;

        case WODM_GETPLAYBACKRATE:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_GETPLAYBACKRATE\r\n")));
            dwRet = m_WaveOut.GetPlaybackRate();
            break;

        case WODM_GETPOS:
            //RETAILMSG(ZONE_WODM, (TEXT("WODM_GETPOS\r\n")));
            dwRet = m_WaveOut.GetPosition((MMTIME *) pParams->dwParam1, pParams->dwParam2);
            break;

        case WODM_GETVOLUME:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_GETVOLUME\r\n")));
            dwRet = m_WaveOut.GetVolume((DWORD *) pParams->dwParam1, pParams->uDeviceId);
            break;

        case WODM_OPEN:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_OPEN\r\n")));
            
            dwRet = m_WaveOut.Open
            (
                (DWORD *)pParams->dwUser,
                (WAVEOPENDESC *)pParams->dwParam1, 
                pParams->dwParam2
            );
            break;

        case WODM_PAUSE:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_PAUSE\r\n")));
            dwRet = m_WaveOut.Pause();
            break;

        case WODM_PREPARE:
            // RETAILMSG(ZONE_WODM, (TEXT("WODM_PREPARE\r\n")));
            dwRet = m_WaveOut.Prepare();
            break;

        case WODM_RESET:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_RESET\r\n")));
            dwRet = m_WaveOut.Reset();
            break;

        case WODM_RESTART:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_RESTART\r\n")));
            dwRet = m_WaveOut.Restart();
            break;

        case WODM_SETPITCH:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_SETPITCH\r\n")));
            dwRet = m_WaveOut.SetPitch();
            break;

        case WODM_SETPLAYBACKRATE:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_SETPLAYBACKRATE\r\n")));
            dwRet = m_WaveOut.SetPlaybackRate();
            break;

        case WODM_SETVOLUME:
            RETAILMSG(ZONE_WODM, (TEXT("WODM_SETVOLUME\r\n")));
            dwRet = m_WaveOut.SetVolume
            ( 
                pParams->dwUser,
                pParams->dwParam1, 
                pParams->uDeviceId 
            );
            break;

        case WODM_UNPREPARE:
            //RETAILMSG(ZONE_WODM, (TEXT("WODM_UNPREPARE\r\n")));
            dwRet = m_WaveOut.Prepare();
            break;

        case WODM_WRITE:

			if( m_bPowerDown )
			{
				extern void I2SReset( void );
				
				I2SReset( );
				m_WaveOut.Restart( );
				//m_WaveOut.m_pCodec->StartPlayback( 0 );
				m_bPowerDown=FALSE;

				Sleep(100 );
			}

            //RETAILMSG(ZONE_WODM, (TEXT("WODM_WRITE\r\n")));
            //dwRet = m_WaveOut.Write((WAVEHDR *)pParams->dwParam1, pParams->dwParam2);
            dwRet = m_WaveOut.Write((WAVEHDR *)pParams->dwParam1, sizeof(WAVEHDR));
            break;

        case WIDM_ADDBUFFER:
            RETAILMSG(ZONE_WIDM, (TEXT("WIDM_ADDBUFFER\r\n")));
            dwRet = m_WaveIn.AddBuffer((PWAVEHDR)pParams->dwParam1, pParams->dwParam2 );
            break;

        case WIDM_CLOSE:
            //RETAILMSG(ZONE_WIDM, (TEXT("WIDM_CLOSE\r\n")));
            dwRet = m_WaveIn.Close();
            break;

        case WIDM_GETDEVCAPS:
            RETAILMSG(ZONE_WIDM, (TEXT("WIDM_GETDEVCAPS\r\n")));
            dwRet = m_WaveIn.GetDevCaps((PWAVEINCAPS)pParams->dwParam1, pParams->dwParam2);
            break;

        case WIDM_GETNUMDEVS:
            RETAILMSG(ZONE_WIDM, (TEXT("WIDM_GETNUMDEVS\r\n")));
            dwRet = m_WaveIn.GetNumDevs();
            break;

        case WIDM_GETPOS:
            RETAILMSG(ZONE_WIDM, (TEXT("WIDM_GETPOS\r\n")));
            dwRet = m_WaveIn.GetPosition((MMTIME *) pParams->dwParam1, pParams->dwParam2);
            break;

        case WIDM_OPEN:
            RETAILMSG(ZONE_WIDM, (TEXT("WIDM_OPEN\r\n")));
            dwRet =  m_WaveIn.Open((WAVEOPENDESC *)pParams->dwParam1, pParams->dwParam2);
            break;

        case WIDM_PREPARE:
            //RETAILMSG(ZONE_WIDM, (TEXT("WIDM_PREPARE\r\n")));
            dwRet =  m_WaveIn.Prepare();
            break;

        case WIDM_RESET:
            RETAILMSG(ZONE_WIDM, (TEXT("WIDM_RESET\r\n")));
            dwRet = m_WaveIn.Reset();
            break;

        case WIDM_START:
            RETAILMSG(ZONE_WIDM, (TEXT("WIDM_START\r\n")));
            dwRet = m_WaveIn.Start();
            break;

        case WIDM_STOP:
            RETAILMSG(ZONE_WIDM, (TEXT("WIDM_STOP\r\n")));
            dwRet = m_WaveIn.Stop();
            break;

        case WIDM_UNPREPARE:
            RETAILMSG(ZONE_WIDM, (TEXT("WIDM_UNPREPARE\r\n")));
            dwRet = m_WaveIn.UnPrepare();
            break;

        default:
            dwRet = MMSYSERR_NOTSUPPORTED;
    }
    return dwRet;
}

#undef		ZONE_WODM
#define		ZONE_WODM	1

//****************************************************************************
// AudioDriver::MixerMessage
//****************************************************************************
// Process all mixer messages.
// 
//
DWORD AudioDriver::MixerMessage(PMMDRV_MESSAGE_PARAMS pParams)
{
    DWORD dwRet;
    DWORD dwParam1, dwParam2;
    UINT uDeviceId;

    // pStream = (HSTREAM) pParams->dwUser;
    dwParam1 = pParams->dwParam1;
    dwParam2 = pParams->dwParam2;
    uDeviceId = pParams->uDeviceId;

//	RETAILMSG(ZONE_WODM, (TEXT("MixerMessage %d \r\n"),uDeviceId));
    if (uDeviceId != 0) 
    {
        return MMSYSERR_BADDEVICEID;
    }


    switch (pParams->uMsg) 
    {
        case MXDM_GETNUMDEVS:
            RETAILMSG(ZONE_WODM, (TEXT("MXDM_GETNUMDEVS\r\n")));
            dwRet = 1;
            break;

        case MXDM_GETDEVCAPS:
            RETAILMSG(ZONE_WODM, (TEXT("MXDM_GETDEVCAPS\r\n")));
            dwRet = m_Mixer.wdev_MXDM_GETDEVCAPS((PMIXERCAPS) pParams->dwParam1, pParams->dwParam2);
            break;

        case MXDM_OPEN:
            RETAILMSG(ZONE_WODM, (TEXT("MXDM_OPEN\r\n")));
            dwRet = m_Mixer.wdev_MXDM_OPEN((PDWORD) pParams->dwUser, (PMIXEROPENDESC) pParams->dwParam1, pParams->dwParam2, m_pCodec);
            break;

        case MXDM_CLOSE:
            RETAILMSG(ZONE_WODM, (TEXT("MXDM_CLOSE\r\n")));
            dwRet = m_Mixer.wdev_MXDM_CLOSE(pParams->dwUser);
            break;

        case MXDM_GETLINEINFO:
            RETAILMSG(ZONE_WODM, (TEXT("MXDM_GETLINEINFO\r\n")));
            dwRet = m_Mixer.wdev_MXDM_GETLINEINFO((PMIXERLINE) pParams->dwParam1, pParams->dwParam2); 
            break;

        case MXDM_GETLINECONTROLS:
            RETAILMSG(ZONE_WODM, (TEXT("MXDM_GETLINECONTROLS\r\n")));
            dwRet = m_Mixer.wdev_MXDM_GETLINECONTROLS((PMIXERLINECONTROLS) pParams->dwParam1, pParams->dwParam2);
            break;

        case MXDM_GETCONTROLDETAILS:
            RETAILMSG(ZONE_WODM, (TEXT("MXDM_GETCONTROLDETAILS\r\n")));
            dwRet = m_Mixer.wdev_MXDM_GETCONTROLDETAILS((PMIXERCONTROLDETAILS) pParams->dwParam1, pParams->dwParam2);
            break;

        case MXDM_SETCONTROLDETAILS:
            RETAILMSG(ZONE_WODM, (TEXT("MXDM_SETCONTROLDETAILS\r\n")));
            dwRet = m_Mixer.wdev_MXDM_SETCONTROLDETAILS((PMIXERCONTROLDETAILS) pParams->dwParam1, pParams->dwParam2);
            break;

        default:
            RETAILMSG(ZONE_WODM, (TEXT("unsupported MIXER message\r\n")));
            dwRet = MMSYSERR_NOTSUPPORTED;
            break;
    }
    return dwRet;
}

//****************************************************************************
// ReadRegistryValue
//****************************************************************************
// Read the DWORD Registry Value
// 
//
DWORD ReadRegistryValue(HKEY hKey, PTSTR szValueName, DWORD dwDefault)
{
    LONG    lStatus;
    ULONG   ulReturnValue;
    DWORD   dwValType = REG_DWORD;
    DWORD   dwValLen = 4;

    lStatus = RegQueryValueEx( hKey, szValueName, NULL, &dwValType, (PBYTE)&ulReturnValue, &dwValLen);
        
    if ((lStatus != ERROR_SUCCESS) || (dwValType != REG_DWORD)) 
    {           
        ulReturnValue = dwDefault;
    } 
 
    return ulReturnValue;
}