windows-nt/Source/XPSP1/NT/enduser/netmeeting/av/nac/medictrl.cpp

935 lines
18 KiB
C++
Raw Permalink Normal View History

2020-09-26 03:20:57 -05:00
#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;
}