935 lines
18 KiB
C++
935 lines
18 KiB
C++
|
|
#include "precomp.h"
|
|
|
|
extern HANDLE g_hEventHalfDuplex;
|
|
|
|
|
|
///////////////////////////////////////////////////////
|
|
//
|
|
// Public methods
|
|
//
|
|
|
|
|
|
MediaControl::MediaControl ( void )
|
|
{
|
|
_Construct ();
|
|
}
|
|
|
|
|
|
MediaControl::~MediaControl ( void )
|
|
{
|
|
_Destruct ();
|
|
}
|
|
|
|
HRESULT MediaControl::Initialize ( MEDIACTRLINIT * p )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
DEBUGMSG (ZONE_VERBOSE, ("MediaControl::Initialize: enter.\r\n"));
|
|
|
|
m_dwFlags = p->dwFlags;
|
|
m_hEvent = NULL;
|
|
|
|
m_uDuration = MC_DEF_DURATION;
|
|
|
|
DEBUGMSG (ZONE_VERBOSE, ("MediaControl::Initialize: exit, hr=0x%lX\r\n", hr));
|
|
|
|
m_hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
|
|
if (m_hEvent == NULL)
|
|
{
|
|
hr = DPR_CANT_CREATE_EVENT;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT MediaControl::RegisterData ( PVOID pDataPtrArray, ULONG cElements )
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (pDataPtrArray == NULL) return DPR_INVALID_PARAMETER;
|
|
|
|
m_ppMediaPkt = (MediaPacket **) pDataPtrArray;
|
|
m_cMediaPkt = cElements;
|
|
hr = DPR_SUCCESS;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT MediaControl::FillMediaPacketInit ( MEDIAPACKETINIT * p )
|
|
{
|
|
if (p == NULL) return DPR_INVALID_PARAMETER;
|
|
|
|
p->pDevFmt = m_pDevFmt;
|
|
|
|
p->cbSizeDevData = m_cbSizeDevData;
|
|
p->cbOffsetDevData = 0;
|
|
|
|
return DPR_SUCCESS;
|
|
}
|
|
|
|
|
|
HRESULT MediaControl::SetProp ( DWORD dwPropId, DWORD_PTR dwPropVal )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
MMRESULT mmr;
|
|
|
|
switch (dwPropId)
|
|
{
|
|
case MC_PROP_MEDIA_STREAM:
|
|
m_hStrm = (DPHANDLE) dwPropVal;
|
|
break;
|
|
|
|
case MC_PROP_MEDIA_DEV_HANDLE:
|
|
m_hDev = (DPHANDLE) dwPropVal;
|
|
break;
|
|
|
|
case MC_PROP_MEDIA_DEV_ID:
|
|
m_uDevId = (UINT) dwPropVal;
|
|
break;
|
|
|
|
case MC_PROP_MEDIA_FORMAT:
|
|
m_pDevFmt = (PVOID) dwPropVal;
|
|
break;
|
|
|
|
case MC_PROP_SIZE:
|
|
m_cbSizeDevData = (DWORD)dwPropVal;
|
|
break;
|
|
|
|
case MC_PROP_PLATFORM:
|
|
m_dwFlags = (DWORD)((m_dwFlags & ~DP_MASK_PLATFORM) | (dwPropVal & DP_MASK_PLATFORM));
|
|
break;
|
|
|
|
case MC_PROP_DURATION:
|
|
m_uDuration = (DWORD)dwPropVal;
|
|
break;
|
|
|
|
case MC_PROP_DUPLEX_TYPE:
|
|
m_dwFlags = (DWORD)((m_dwFlags & ~DP_MASK_DUPLEX) | (dwPropVal & DP_MASK_DUPLEX));
|
|
break;
|
|
|
|
case MC_PROP_STATE:
|
|
hr = DPR_IMPOSSIBLE_SET_PROP;
|
|
break;
|
|
|
|
case MC_PROP_AUDIO_JAMMED:
|
|
m_fJammed = (DWORD)dwPropVal;
|
|
break;
|
|
|
|
default:
|
|
hr = DPR_INVALID_PROP_ID;
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT MediaControl::GetProp ( DWORD dwPropId, PDWORD_PTR pdwPropVal )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
|
|
if (pdwPropVal)
|
|
{
|
|
switch (dwPropId)
|
|
{
|
|
case MC_PROP_MEDIA_STREAM:
|
|
*pdwPropVal = (DWORD_PTR) m_hStrm;
|
|
break;
|
|
|
|
case MC_PROP_MEDIA_DEV_HANDLE:
|
|
*pdwPropVal = (DWORD_PTR) m_hDev;
|
|
break;
|
|
|
|
case MC_PROP_MEDIA_DEV_ID:
|
|
*pdwPropVal = (DWORD) m_uDevId;
|
|
break;
|
|
|
|
case MC_PROP_MEDIA_FORMAT:
|
|
*pdwPropVal = (DWORD_PTR) m_pDevFmt;
|
|
break;
|
|
|
|
case MC_PROP_SIZE:
|
|
*pdwPropVal = (DWORD) m_cbSizeDevData;
|
|
break;
|
|
|
|
case MC_PROP_PLATFORM:
|
|
*pdwPropVal = m_dwFlags & DP_MASK_PLATFORM;
|
|
break;
|
|
|
|
case MC_PROP_STATE:
|
|
*pdwPropVal = m_uState;
|
|
break;
|
|
|
|
case MC_PROP_DURATION:
|
|
*pdwPropVal = m_uDuration;
|
|
break;
|
|
|
|
case MC_PROP_DUPLEX_TYPE:
|
|
*pdwPropVal = m_dwFlags & DP_MASK_DUPLEX;
|
|
break;
|
|
|
|
case MC_PROP_EVENT_HANDLE:
|
|
*pdwPropVal = (DWORD_PTR) m_hEvent;
|
|
break;
|
|
|
|
case MC_PROP_AUDIO_JAMMED:
|
|
*pdwPropVal = (DWORD)(m_fJammed ? TRUE : FALSE);
|
|
break;
|
|
|
|
default:
|
|
hr = DPR_INVALID_PROP_ID;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_INVALID_PARAMETER;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT MediaControl::PrepareHeaders ( void )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
MediaPacket **pp;
|
|
ULONG uc;
|
|
|
|
if (m_hDev)
|
|
{
|
|
if (m_ppMediaPkt == NULL)
|
|
{
|
|
hr = DPR_INVALID_PARAMETER;
|
|
goto MyExit;
|
|
}
|
|
|
|
for (uc = m_cMediaPkt, pp = m_ppMediaPkt; uc--; pp++)
|
|
{
|
|
if (*pp)
|
|
{
|
|
hr = (*pp)->Open (MP_TYPE_DEV, m_hDev);
|
|
if (hr != DPR_SUCCESS)
|
|
{
|
|
goto MyExit;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
MyExit:
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT MediaControl::UnprepareHeaders ( void )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
MediaPacket **pp;
|
|
ULONG uc;
|
|
|
|
if (m_hDev)
|
|
{
|
|
if (m_ppMediaPkt == NULL)
|
|
{
|
|
hr = DPR_INVALID_PARAMETER;
|
|
goto MyExit;
|
|
}
|
|
|
|
for (uc = m_cMediaPkt, pp = m_ppMediaPkt; uc--; pp++)
|
|
{
|
|
if (*pp)
|
|
{
|
|
hr = (*pp)->Close (MP_TYPE_DEV);
|
|
if (hr != DPR_SUCCESS)
|
|
{
|
|
goto MyExit;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// LAURABU 11/24/99
|
|
// Messes up pausing/unpausing audio
|
|
// Had added this to fix faults pausing/unpausing video
|
|
//
|
|
// m_cMediaPkt = 0;
|
|
// m_ppMediaPkt = NULL;
|
|
//
|
|
}
|
|
|
|
MyExit:
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT MediaControl::Release ( void )
|
|
{
|
|
_Destruct ();
|
|
return DPR_SUCCESS;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////
|
|
//
|
|
// Private methods
|
|
//
|
|
|
|
|
|
void MediaControl::_Construct ( void )
|
|
{
|
|
m_dwFlags = 0;
|
|
|
|
m_hStrm = NULL;
|
|
|
|
m_uDevId = 0;
|
|
|
|
m_hDev = NULL;
|
|
m_pDevFmt = NULL;
|
|
m_uDuration = 0;
|
|
m_cbSizeDevData = 0;
|
|
|
|
m_uState = 0;
|
|
|
|
m_hEvent = NULL;
|
|
|
|
m_ppMediaPkt = NULL;
|
|
m_cMediaPkt = 0;
|
|
|
|
m_fJammed = FALSE;
|
|
}
|
|
|
|
|
|
void MediaControl::_Destruct ( void )
|
|
{
|
|
if (m_hDev) {
|
|
// waveInOut/UnprepareHeaders() and waveIn/OutClose() can fail if the
|
|
// device is still playing. Need to Reset() first!
|
|
Reset();
|
|
UnprepareHeaders ();
|
|
Close ();
|
|
}
|
|
|
|
if (m_hEvent)
|
|
{
|
|
CloseHandle (m_hEvent);
|
|
m_hEvent = NULL;
|
|
}
|
|
}
|
|
|
|
WaveInControl::WaveInControl()
|
|
{
|
|
}
|
|
|
|
WaveInControl::~WaveInControl()
|
|
{
|
|
}
|
|
|
|
WaveOutControl::WaveOutControl()
|
|
{
|
|
m_uPosition = 0;
|
|
m_uVolume = 0;
|
|
}
|
|
|
|
WaveOutControl::~WaveOutControl()
|
|
{
|
|
}
|
|
|
|
HRESULT WaveInControl::Initialize ( MEDIACTRLINIT * p )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
DEBUGMSG (ZONE_VERBOSE, ("WaveInControl::Initialize: enter.\r\n"));
|
|
|
|
if ((hr =MediaControl::Initialize( p)) != DPR_SUCCESS)
|
|
return hr;
|
|
|
|
m_uTimeout = MC_DEF_RECORD_TIMEOUT;
|
|
|
|
m_uPrefeed = MC_DEF_RECORD_BUFS;
|
|
|
|
m_uSilenceDuration = MC_DEF_SILENCE_DURATION;
|
|
|
|
DEBUGMSG (ZONE_VERBOSE, ("WaveInControl::Initialize: exit, hr=0x%lX\r\n", hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT WaveOutControl::Initialize ( MEDIACTRLINIT * p )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
DEBUGMSG (ZONE_VERBOSE, ("WaveOutControl::Initialize: enter.\r\n"));
|
|
|
|
if ((hr =MediaControl::Initialize( p)) != DPR_SUCCESS)
|
|
return hr;
|
|
|
|
m_uTimeout = MC_DEF_PLAY_TIMEOUT;
|
|
|
|
m_uPrefeed = MC_DEF_PLAY_BUFS;
|
|
|
|
m_uVolume = MC_DEF_VOLUME;
|
|
|
|
DEBUGMSG (ZONE_VERBOSE, ("WaveOutControl::Initialize: exit, hr=0x%lX\r\n", hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT WaveInControl::Configure ( MEDIACTRLCONFIG * p )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
UINT uBlockAlign;
|
|
|
|
DEBUGMSG (ZONE_VERBOSE, ("WaveInControl::Configure: enter.\r\n"));
|
|
|
|
|
|
m_hStrm = p->hStrm;
|
|
m_uDevId = p->uDevId;
|
|
m_pDevFmt = p->pDevFmt;
|
|
|
|
if (m_pDevFmt == NULL) return DPR_INVALID_PARAMETER;
|
|
|
|
|
|
if ((m_uDuration = p->uDuration) == MC_USING_DEFAULT)
|
|
{
|
|
m_cbSizeDevData = ((WAVEFORMAT *) m_pDevFmt)->nAvgBytesPerSec * p->cbSamplesPerPkt
|
|
/((WAVEFORMAT *) m_pDevFmt)->nSamplesPerSec;
|
|
m_uDuration = p->cbSamplesPerPkt*1000 /((WAVEFORMAT *) m_pDevFmt)->nSamplesPerSec;
|
|
} else {
|
|
// roughly calculate the buffer size based on 20ms
|
|
m_cbSizeDevData = ((WAVEFORMAT *) m_pDevFmt)->nAvgBytesPerSec
|
|
* m_uDuration / 1000;
|
|
|
|
// need to be on the block alignment boundary
|
|
uBlockAlign = ((WAVEFORMAT *) m_pDevFmt)->nBlockAlign;
|
|
m_cbSizeDevData = ((m_cbSizeDevData + uBlockAlign - 1) / uBlockAlign)
|
|
* uBlockAlign;
|
|
}
|
|
|
|
|
|
DEBUGMSG (ZONE_VERBOSE, ("WaveInControl::Configure: exit, hr=0x%lX\r\n", hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT WaveOutControl::Configure ( MEDIACTRLCONFIG * p )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
UINT uBlockAlign;
|
|
|
|
DEBUGMSG (ZONE_VERBOSE, ("WaveOutControl::Configure: enter.\r\n"));
|
|
|
|
|
|
m_hStrm = p->hStrm;
|
|
m_uDevId = p->uDevId;
|
|
m_pDevFmt = p->pDevFmt;
|
|
|
|
if (m_pDevFmt == NULL) return DPR_INVALID_PARAMETER;
|
|
|
|
|
|
if ((m_uDuration = p->uDuration) == MC_USING_DEFAULT)
|
|
{
|
|
m_cbSizeDevData = ((WAVEFORMAT *) m_pDevFmt)->nAvgBytesPerSec * p->cbSamplesPerPkt
|
|
/((WAVEFORMAT *) m_pDevFmt)->nSamplesPerSec;
|
|
m_uDuration = p->cbSamplesPerPkt*1000 /((WAVEFORMAT *) m_pDevFmt)->nSamplesPerSec;
|
|
} else {
|
|
// roughly calculate the buffer size based on 20ms
|
|
m_cbSizeDevData = ((WAVEFORMAT *) m_pDevFmt)->nAvgBytesPerSec
|
|
* m_uDuration / 1000;
|
|
|
|
// need to be on the block alignment boundary
|
|
uBlockAlign = ((WAVEFORMAT *) m_pDevFmt)->nBlockAlign;
|
|
m_cbSizeDevData = ((m_cbSizeDevData + uBlockAlign - 1) / uBlockAlign)
|
|
* uBlockAlign;
|
|
}
|
|
|
|
DEBUGMSG (ZONE_VERBOSE, ("MediaControl::Configure: exit, hr=0x%lX\r\n", hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT WaveInControl::Open ( void )
|
|
{
|
|
HRESULT hr = DPR_INVALID_PLATFORM;
|
|
MMRESULT mmr;
|
|
DWORD dwfOpen;
|
|
UINT uDevId;
|
|
|
|
m_hDev = NULL;
|
|
|
|
dwfOpen = CALLBACK_EVENT;
|
|
uDevId = (m_uDevId == (UINT) -1) ? WAVE_MAPPER : m_uDevId;
|
|
mmr = waveInOpen ((HWAVEIN *) &m_hDev, uDevId,
|
|
(WAVEFORMATEX *) m_pDevFmt,
|
|
(DWORD_PTR) m_hEvent, 0, dwfOpen);
|
|
// begin hack
|
|
if (mmr == WAVERR_BADFORMAT && uDevId != WAVE_MAPPER) {
|
|
// the sound card probably doesnt support our sample size or sample rate
|
|
// (16 bit, 8Khz)
|
|
// Try using the WAVE_MAPPER. The WAVE_MAPPER may end up using
|
|
// a different device than the one we wanted !!
|
|
DEBUGMSG (1, ("MediaControl::Open: bad format, trying WAVE_MAPPER\r\n" ));
|
|
mmr = waveInOpen ((HWAVEIN *) &m_hDev, WAVE_MAPPER,
|
|
(WAVEFORMATEX *) m_pDevFmt,
|
|
(DWORD_PTR) m_hEvent, 0, dwfOpen);
|
|
if (mmr == MMSYSERR_NOERROR)
|
|
m_uDevId = (UINT) -1; // use WAVE_MAPPER next time
|
|
}
|
|
|
|
// end hack
|
|
if (mmr != MMSYSERR_NOERROR)
|
|
{
|
|
DEBUGMSG (1, ("MediaControl::Open: waveInOpen failed, mmr=%ld\r\n", (ULONG) mmr));
|
|
hr = DPR_CANT_OPEN_WAVE_DEV;
|
|
goto MyExit;
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_SUCCESS;
|
|
}
|
|
|
|
MyExit:
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT WaveOutControl::Open ( void )
|
|
{
|
|
HRESULT hr = DPR_INVALID_PLATFORM;
|
|
MMRESULT mmr;
|
|
DWORD dwfOpen;
|
|
UINT uDevId;
|
|
|
|
m_hDev = NULL;
|
|
|
|
dwfOpen = CALLBACK_EVENT;
|
|
uDevId = (m_uDevId == (UINT) -1) ? WAVE_MAPPER : m_uDevId;
|
|
mmr = waveOutOpen ((HWAVEOUT *) &m_hDev, uDevId,
|
|
(WAVEFORMATEX *) m_pDevFmt,
|
|
(DWORD_PTR) m_hEvent, 0, dwfOpen);
|
|
// begin hack
|
|
if (mmr == WAVERR_BADFORMAT && uDevId != WAVE_MAPPER) {
|
|
// the sound card probably doesnt support our sample size or sample rate
|
|
// (16 bit, 8Khz)
|
|
// Try using the WAVE_MAPPER. The WAVE_MAPPER may end up using
|
|
// a different device than the one we wanted !!
|
|
DEBUGMSG (1, ("MediaControl::Open: bad format, trying WAVE_MAPPER\r\n" ));
|
|
mmr = waveOutOpen((HWAVEOUT *) &m_hDev, WAVE_MAPPER,
|
|
(WAVEFORMATEX *) m_pDevFmt,
|
|
(DWORD_PTR) m_hEvent, 0, dwfOpen);
|
|
if (mmr == MMSYSERR_NOERROR)
|
|
m_uDevId = (UINT) -1; // use WAVE_MAPPER next time
|
|
}
|
|
// end hack
|
|
if (mmr != MMSYSERR_NOERROR)
|
|
{
|
|
DEBUGMSG (1, ("MediaControl::Open: waveOutOpen failed, mmr=%ld\r\n", (ULONG) mmr));
|
|
hr = DPR_CANT_OPEN_WAVE_DEV;
|
|
goto MyExit;
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_SUCCESS;
|
|
}
|
|
|
|
MyExit:
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT WaveInControl::Close ( void )
|
|
{
|
|
HRESULT hr = DPR_INVALID_PLATFORM;
|
|
MMRESULT mmr;
|
|
|
|
if (m_hDev)
|
|
{
|
|
mmr = waveInClose ((HWAVEIN) m_hDev);
|
|
if (mmr != MMSYSERR_NOERROR)
|
|
{
|
|
DEBUGMSG (1, ("MediaControl::CloseAudioDev: waveInClose failed, mmr=%ld\r\n", (ULONG) mmr));
|
|
hr = DPR_CANT_CLOSE_WAVE_DEV;
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_SUCCESS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_INVALID_HANDLE;
|
|
}
|
|
|
|
m_hDev = NULL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT WaveOutControl::Close ( void )
|
|
{
|
|
HRESULT hr = DPR_INVALID_PLATFORM;
|
|
MMRESULT mmr;
|
|
|
|
if (m_hDev)
|
|
{
|
|
mmr = waveOutClose ((HWAVEOUT) m_hDev);
|
|
if (mmr != MMSYSERR_NOERROR)
|
|
{
|
|
DEBUGMSG (1, ("MediaControl::CloseAudioDev: waveOutClose failed, mmr=%ld\r\n", (ULONG) mmr));
|
|
hr = DPR_CANT_CLOSE_WAVE_DEV;
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_SUCCESS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_INVALID_HANDLE;
|
|
}
|
|
|
|
m_hDev = NULL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT WaveInControl::Start ( void )
|
|
{
|
|
HRESULT hr = DPR_INVALID_PLATFORM;
|
|
MMRESULT mmr;
|
|
|
|
if (m_hDev)
|
|
{
|
|
mmr = waveInStart ((HWAVEIN) m_hDev);
|
|
if (mmr != MMSYSERR_NOERROR)
|
|
{
|
|
DEBUGMSG (1, ("MediaControl::StartAudioDev: waveInStart failed, mmr=%ld\r\n", (ULONG) mmr));
|
|
hr = DPR_CANT_START_WAVE_DEV;
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_SUCCESS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_INVALID_HANDLE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT WaveOutControl::Start ( void )
|
|
{
|
|
return DPR_SUCCESS;
|
|
}
|
|
|
|
HRESULT WaveOutControl::Stop( void )
|
|
{
|
|
return DPR_INVALID_PARAMETER;
|
|
}
|
|
|
|
HRESULT WaveInControl::Stop ( void )
|
|
{
|
|
HRESULT hr = DPR_INVALID_PLATFORM;
|
|
MMRESULT mmr;
|
|
|
|
if (m_hDev)
|
|
{
|
|
mmr = waveInStop ((HWAVEIN) m_hDev);
|
|
if (mmr != MMSYSERR_NOERROR)
|
|
{
|
|
DEBUGMSG (1, ("MediaControl::StopAudioDev: waveInStop failed, mmr=%ld\r\n", (ULONG) mmr));
|
|
hr = DPR_CANT_STOP_WAVE_DEV;
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_SUCCESS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_INVALID_HANDLE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT WaveInControl::Reset ( void )
|
|
{
|
|
HRESULT hr;
|
|
MMRESULT mmr;
|
|
|
|
if (m_hDev)
|
|
{
|
|
mmr = waveInReset ((HWAVEIN) m_hDev);
|
|
if (mmr != MMSYSERR_NOERROR)
|
|
{
|
|
DEBUGMSG (1, ("MediaControl::ResetAudioDev: waveInReset failed, mmr=%ld\r\n", (ULONG) mmr));
|
|
hr = DPR_CANT_RESET_WAVE_DEV;
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_SUCCESS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_INVALID_HANDLE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT WaveOutControl::Reset ( void )
|
|
{
|
|
HRESULT hr;
|
|
MMRESULT mmr;
|
|
|
|
if (m_hDev)
|
|
{
|
|
|
|
mmr = waveOutReset ((HWAVEOUT) m_hDev);
|
|
if (mmr != MMSYSERR_NOERROR)
|
|
{
|
|
DEBUGMSG (1, ("MediaControl::ResetAudioDev: waveOutReset failed, mmr=%ld\r\n", (ULONG) mmr));
|
|
hr = DPR_CANT_RESET_WAVE_DEV;
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_SUCCESS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_INVALID_HANDLE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT WaveInControl::SetProp ( DWORD dwPropId, DWORD_PTR dwPropVal )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
MMRESULT mmr;
|
|
|
|
switch (dwPropId)
|
|
{
|
|
|
|
case MC_PROP_VOICE_SWITCH:
|
|
m_dwFlags = (DWORD)((m_dwFlags & ~DP_MASK_VOICESWITCH) | (dwPropVal & DP_MASK_VOICESWITCH));
|
|
break;
|
|
|
|
|
|
case MC_PROP_SILENCE_DURATION:
|
|
if (dwPropVal == MC_USING_DEFAULT)
|
|
m_uSilenceDuration = MC_DEF_SILENCE_DURATION;
|
|
else
|
|
m_uSilenceDuration = (DWORD)dwPropVal; //ms
|
|
break;
|
|
|
|
case MC_PROP_TIMEOUT:
|
|
m_uTimeout = (DWORD)dwPropVal;
|
|
break;
|
|
|
|
case MC_PROP_PREFEED:
|
|
m_uPrefeed = (DWORD)dwPropVal;
|
|
break;
|
|
|
|
default:
|
|
hr = MediaControl::SetProp(dwPropId, dwPropVal );
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT WaveOutControl::SetProp ( DWORD dwPropId, DWORD_PTR dwPropVal )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
MMRESULT mmr;
|
|
|
|
switch (dwPropId)
|
|
{
|
|
|
|
case MC_PROP_VOICE_SWITCH:
|
|
m_dwFlags = (DWORD)((m_dwFlags & ~DP_MASK_VOICESWITCH) | (dwPropVal & DP_MASK_VOICESWITCH));
|
|
break;
|
|
|
|
case MC_PROP_VOLUME:
|
|
if (m_dwFlags & DP_FLAG_SEND)
|
|
{
|
|
hr = DPR_INVALID_PARAMETER;
|
|
goto MyExit;
|
|
}
|
|
if (dwPropVal == MC_USING_DEFAULT) // dont change the volume
|
|
break;
|
|
// this is in units of % of maximum. Scale it to mmsystem.
|
|
dwPropVal = min(dwPropVal, 100);
|
|
dwPropVal *= 655;
|
|
dwPropVal |= (dwPropVal << 16);
|
|
mmr = waveOutSetVolume ((HWAVEOUT) m_hDev, (DWORD)dwPropVal);
|
|
if (mmr != MMSYSERR_NOERROR)
|
|
{
|
|
hr = DPR_CANT_SET_VOLUME;
|
|
goto MyExit;
|
|
}
|
|
|
|
m_uVolume = (DWORD)dwPropVal;
|
|
break;
|
|
|
|
case MC_PROP_TIMEOUT:
|
|
m_uTimeout = (DWORD)dwPropVal;
|
|
break;
|
|
|
|
case MC_PROP_PREFEED:
|
|
m_uPrefeed = (DWORD)dwPropVal;
|
|
break;
|
|
|
|
default:
|
|
hr = MediaControl::SetProp(dwPropId, dwPropVal );
|
|
break;
|
|
}
|
|
|
|
MyExit:
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
char LogScale[] = {0, 3, 6, 9, 11, 13, 15,
|
|
17, 19, 21, 23, 24, 26, 27, 28, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
|
|
42, 43, 43, 44, 45, 46, 46, 47, 48, 48, 49, 50, 50, 51, 51, 52, 52, 53, 54, 54,
|
|
55, 55, 56, 56, 57, 57, 58, 58, 59, 59, 59, 60, 60, 61, 61, 62, 62, 62, 63, 63,
|
|
64, 64, 64, 65, 65, 65, 66, 66, 66, 67, 67, 67, 68, 68, 68, 69, 69, 69, 70, 70,
|
|
70, 71, 71, 71, 71, 72, 72, 72, 73, 73, 73, 73, 74, 74, 74, 74, 75, 75, 75, 75,
|
|
76, 76, 76, 76, 77, 77, 77, 77, 78, 78, 78, 78, 79, 79, 79, 79, 79, 80, 80, 80,
|
|
80, 81, 81, 81, 81, 81, 82, 82, 82, 82, 82, 83, 83, 83, 83, 83, 84, 84, 84, 84,
|
|
84, 84, 85, 85, 85, 85, 85, 86, 86, 86, 86, 86, 86, 87, 87, 87, 87, 87, 87, 88,
|
|
88, 88, 88, 88, 88, 89, 89, 89, 89, 89, 89, 89, 90, 90, 90, 90, 90, 90, 91, 91,
|
|
91, 91, 91, 91, 91, 92, 92, 92, 92, 92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 93,
|
|
94, 94, 94, 94, 94, 94, 94, 95, 95, 95, 95, 95, 95, 95, 95, 96, 96, 96, 96, 96,
|
|
96, 96, 96, 97, 97, 97, 97, 97, 97, 97, 97, 97, 98, 98, 98, 98, 98, 98, 98, 98,
|
|
99, 99, 99, 99, 99, 99, 99, 99, 100};
|
|
|
|
|
|
HRESULT WaveInControl::GetProp ( DWORD dwPropId, PDWORD_PTR pdwPropVal )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
|
|
if (pdwPropVal)
|
|
{
|
|
switch (dwPropId)
|
|
{
|
|
case MC_PROP_SILENCE_DURATION:
|
|
*pdwPropVal = m_uSilenceDuration;
|
|
break;
|
|
|
|
case MC_PROP_TIMEOUT:
|
|
*pdwPropVal = m_uTimeout;
|
|
break;
|
|
|
|
case MC_PROP_PREFEED:
|
|
*pdwPropVal = m_uPrefeed;
|
|
break;
|
|
|
|
case MC_PROP_VOICE_SWITCH:
|
|
*pdwPropVal = m_dwFlags & DP_MASK_VOICESWITCH;
|
|
break;
|
|
|
|
case MC_PROP_SPP:
|
|
// *pdwPropVal = (DWORD) ((WAVEFORMATEX *) m_pDevFmt)->nSamplesPerSec
|
|
// * m_uDuration / 100UL;
|
|
*pdwPropVal = m_cbSizeDevData * (DWORD) ((WAVEFORMATEX *) m_pDevFmt)->nSamplesPerSec
|
|
/(DWORD) ((WAVEFORMATEX *) m_pDevFmt)->nAvgBytesPerSec;
|
|
break;
|
|
|
|
case MC_PROP_SPS:
|
|
*pdwPropVal = (DWORD) ((WAVEFORMATEX *) m_pDevFmt)->nSamplesPerSec;
|
|
|
|
break;
|
|
|
|
default:
|
|
hr = MediaControl::GetProp( dwPropId, pdwPropVal );
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_INVALID_PARAMETER;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT WaveOutControl::GetProp ( DWORD dwPropId, PDWORD_PTR pdwPropVal )
|
|
{
|
|
HRESULT hr = DPR_SUCCESS;
|
|
|
|
if (pdwPropVal)
|
|
{
|
|
switch (dwPropId)
|
|
{
|
|
case MC_PROP_VOLUME:
|
|
*pdwPropVal = m_uVolume;
|
|
break;
|
|
|
|
case MC_PROP_TIMEOUT:
|
|
*pdwPropVal = m_uTimeout;
|
|
break;
|
|
|
|
case MC_PROP_PREFEED:
|
|
*pdwPropVal = m_uPrefeed;
|
|
break;
|
|
|
|
case MC_PROP_VOICE_SWITCH:
|
|
*pdwPropVal = m_dwFlags & DP_MASK_VOICESWITCH;
|
|
break;
|
|
|
|
case MC_PROP_SPP:
|
|
// *pdwPropVal = (DWORD) ((WAVEFORMATEX *) m_pDevFmt)->nSamplesPerSec
|
|
// * m_uDuration / 100UL;
|
|
*pdwPropVal = m_cbSizeDevData * (DWORD) ((WAVEFORMATEX *) m_pDevFmt)->nSamplesPerSec
|
|
/(DWORD) ((WAVEFORMATEX *) m_pDevFmt)->nAvgBytesPerSec;
|
|
break;
|
|
|
|
case MC_PROP_SPS:
|
|
*pdwPropVal = (DWORD) ((WAVEFORMATEX *) m_pDevFmt)->nSamplesPerSec;
|
|
|
|
break;
|
|
|
|
default:
|
|
hr = MediaControl::GetProp( dwPropId, pdwPropVal );
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DPR_INVALID_PARAMETER;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|