wav.cpp

CIRRUS 公司EP93XX系列CPU的WINCE下的BSP

    else
    {
        //  
        // In order to enable the audio section on the EDB9315 you must clear 
        // GPIO 8.
        //
        // if(bClearGPIO8)
        // {
        //    HalWriteCommonReg
        //    (
        //        GPIO_PBDDR, 
        //        0x1,
        //        0x1
        //    );
        //    HalWriteCommonReg
        //    (
        //        GPIO_PBDR, 
        //        0x1,
        //        0x0
        //    );
        //}

        //
        // Initialize the I2S mixer
        //
        dwRet = m_I2S.Initialize();
        if(MMSUCCESS(dwRet))
        {
            m_pCodec = &m_I2S;
            m_pMixer = &m_I2SMixer;
        }        
        if(!MMSUCCESS(dwRet))
        {
            ERRORMSG(ZONE_ERROR, (L"AudioDriver::Initialize: Failed to initialize I2S Codec\n" )) ;
        }

        //
        // The EDB9301 uses EGPIO1 as a mute.
        //         
        if(bSetGPIO1)
        {
            HalWriteCommonReg
            (
                GPIO_PADDR, 
                0x2,
                0x2
            );
            HalWriteCommonReg
            (
                GPIO_PADR, 
                0x2,
                0x2
            );
        }
    }

    //
    // 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:
            PRINTMSG(ZONE_WODM, (TEXT("WODM_BREAKLOOP\r\n")));
            dwRet = m_WaveOut.BreakLoop();
            break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        case WODM_UNPREPARE:
            //PRINTMSG(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 );
			}

            //PRINTMSG(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:
            PRINTMSG(ZONE_WIDM, (TEXT("WIDM_ADDBUFFER\r\n")));
            dwRet = m_WaveIn.AddBuffer((PWAVEHDR)pParams->dwParam1, pParams->dwParam2 );
            break;

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

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

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

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

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

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

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

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

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

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

        default:
            dwRet = MMSYSERR_NOTSUPPORTED;
    }
    return dwRet;
}

//****************************************************************************
// 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;

    if (uDeviceId != 0) 
    {
        return MMSYSERR_BADDEVICEID;
    }


    switch (pParams->uMsg) 
    {
        // mixer API messages:
        // only 
        // only purpose of mixer handles at driver level is to provide a target for callbacks.
        // as such, only really need one handle per device. if client application(s) open more than one
        // mixer handle, the mixer API should MUX them, so driver only have has to manage a single instance.
        case MXDM_GETNUMDEVS:
            dwRet = 1;
            break;

        case MXDM_GETDEVCAPS:
            dwRet = m_pMixer->GetMixerCaps((PMIXERCAPS) dwParam1);
            break;

        case MXDM_OPEN:
            dwRet = m_pMixer->OpenMixerHandle((PDWORD) pParams->dwUser, (PMIXEROPENDESC) dwParam1, dwParam2);
            break;

        case MXDM_CLOSE:
            dwRet = m_pMixer->CloseMixerHandle(dwParam2);
            break;

        case MXDM_GETLINECONTROLS:
            dwRet = m_pMixer->GetMixerLineControls((PMIXERLINECONTROLS) dwParam1, dwParam2);
            break;

        case MXDM_GETLINEINFO:
            dwRet = m_pMixer->GetMixerLineInfo((PMIXERLINE) dwParam1, dwParam2);
            break;

        case MXDM_GETCONTROLDETAILS:
            dwRet = m_pMixer->GetMixerControlDetails((PMIXERCONTROLDETAILS) dwParam1, dwParam2);
            break;

        case MXDM_SETCONTROLDETAILS:
            dwRet = m_pMixer->SetMixerControlDetails((PMIXERCONTROLDETAILS) dwParam1, dwParam2);
            break;

        default:
            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;
}