1645 lines
41 KiB
C++
1645 lines
41 KiB
C++
#include "precomp.h"
|
||
#include <nmdsprv.h>
|
||
|
||
//bytes <-> PCM16 samples
|
||
inline UINT BYTESTOSAMPLES(UINT bytes) { return bytes/2;}
|
||
inline UINT SAMPLESTOBYTES(UINT samples) {return samples*2;}
|
||
// 'quick' modulo operator. reason its quick is because it only works if -mod < x < 2*mod
|
||
inline UINT QMOD(const int x, const int mod)
|
||
{ if (x >= mod)
|
||
return (x-mod);
|
||
if (x < 0)
|
||
return (x+mod);
|
||
else
|
||
return x;
|
||
}
|
||
|
||
#define BUFFER_RECEIVED 1 // used to indicate that the buffer is ready to play
|
||
#define BUFFER_SILENT 2 // buffer appears to be silent
|
||
|
||
#define DSFLAG_ALLOCATED 1
|
||
|
||
const int MIN_DSBUF_SIZE = 4000;
|
||
|
||
struct DSINFO {
|
||
struct DSINFO *pNext;
|
||
DWORD flags;
|
||
GUID guid;
|
||
LPSTR pszDescription;
|
||
LPSTR pszModule;
|
||
LPDIRECTSOUND pDS;
|
||
LPDIRECTSOUNDBUFFER pDSPrimaryBuf;
|
||
UINT uRef;
|
||
};
|
||
|
||
// initial all the globals
|
||
DSINFO *DirectSoundMgr::m_pDSInfoList = NULL;
|
||
BOOL DirectSoundMgr::m_fInitialized = FALSE;
|
||
HINSTANCE DirectSoundMgr::m_hDS = NULL;
|
||
LPFNDSCREATE DirectSoundMgr::m_pDirectSoundCreate=NULL;
|
||
LPFNDSENUM DirectSoundMgr::m_pDirectSoundEnumerate=NULL;
|
||
|
||
GUID myNullGuid = {0};
|
||
|
||
HRESULT DirectSoundMgr::Initialize()
|
||
{
|
||
HRESULT hr;
|
||
|
||
// currently there seems no need to re-enumerate the list of devices
|
||
// but that can be changed if the need arises
|
||
if (m_fInitialized)
|
||
return (m_pDSInfoList == NULL ? DPR_NO_PLAY_CAP : S_OK);
|
||
|
||
ASSERT(!m_pDSInfoList);
|
||
m_hDS = ::LoadLibrary("DSOUND");
|
||
if (m_hDS != NULL)
|
||
{
|
||
if (GetProcAddress(m_hDS, "DirectSoundCaptureCreate") // this identifies DS5 or later
|
||
&& (m_pDirectSoundCreate = (LPFNDSCREATE)GetProcAddress(m_hDS,"DirectSoundCreate"))
|
||
&& (m_pDirectSoundEnumerate = (LPFNDSENUM)GetProcAddress(m_hDS,"DirectSoundEnumerateA"))
|
||
)
|
||
{
|
||
if ((hr=(*m_pDirectSoundEnumerate)(DSEnumCallback, 0)) != S_OK)
|
||
{
|
||
DEBUGMSG(ZONE_DP,("DSEnumerate failed with %x\n",hr));
|
||
} else {
|
||
if (!m_pDSInfoList) {
|
||
DEBUGMSG(ZONE_DP,("DSEnumerate - no devices found\n"));
|
||
hr = DPR_NO_PLAY_CAP; // no devices were found
|
||
}
|
||
}
|
||
|
||
} else {
|
||
hr = DPR_INVALID_PLATFORM; // better error code?
|
||
}
|
||
if (hr != S_OK) {
|
||
FreeLibrary(m_hDS);
|
||
m_hDS = NULL;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
DEBUGMSG(ZONE_INIT,("LoadLibrary(DSOUND) failed"));
|
||
hr = DPR_NO_PLAY_CAP;
|
||
}
|
||
|
||
m_fInitialized = TRUE;
|
||
return hr;
|
||
}
|
||
|
||
|
||
HRESULT DirectSoundMgr::UnInitialize()
|
||
{
|
||
DSINFO *pDSINFO = m_pDSInfoList, *pDSNEXT;
|
||
if (m_fInitialized)
|
||
{
|
||
|
||
while (pDSINFO)
|
||
{
|
||
pDSNEXT = pDSINFO->pNext;
|
||
delete [] pDSINFO->pszDescription;
|
||
delete [] pDSINFO->pszModule;
|
||
delete pDSINFO;
|
||
pDSINFO = pDSNEXT;
|
||
}
|
||
|
||
m_fInitialized = FALSE;
|
||
m_pDSInfoList = NULL;
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
BOOL __stdcall DirectSoundMgr::DSEnumCallback(
|
||
LPGUID lpGuid,
|
||
LPCSTR lpstrDescription,
|
||
LPCSTR lpstrModule,
|
||
LPVOID lpContext
|
||
)
|
||
{
|
||
DSINFO *pDSInfo;
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
pDSInfo = new DSINFO;
|
||
if (pDSInfo) {
|
||
pDSInfo->uRef = 0;
|
||
pDSInfo->guid = (lpGuid ? *lpGuid : GUID_NULL);
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
pDSInfo->pszDescription = new CHAR [lstrlen(lpstrDescription)+1];
|
||
if (pDSInfo->pszDescription)
|
||
lstrcpy(pDSInfo->pszDescription, lpstrDescription);
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
pDSInfo->pszModule = new CHAR [lstrlen(lpstrModule)+1];
|
||
if (pDSInfo->pszModule)
|
||
lstrcpy(pDSInfo->pszModule, lpstrModule);
|
||
|
||
// append to list
|
||
pDSInfo->pNext = m_pDSInfoList;
|
||
m_pDSInfoList = pDSInfo;
|
||
}
|
||
DEBUGMSG(ZONE_DP,("DSound device found: (%s) ; driver (%s);\n",lpstrDescription, lpstrModule));
|
||
return TRUE;
|
||
}
|
||
|
||
HRESULT
|
||
DirectSoundMgr::MapWaveIdToGuid(UINT waveId, GUID *pGuid)
|
||
{
|
||
// try to figure out which Guid maps to a wave id
|
||
// Do this by opening the wave device corresponding to the wave id and then
|
||
// all the DS devices in sequence and see which one fails.
|
||
// Yes, this is a monstrous hack and clearly unreliable
|
||
HWAVEOUT hWaveOut = NULL;
|
||
MMRESULT mmr;
|
||
HRESULT hr;
|
||
DSINFO *pDSInfo;
|
||
LPDIRECTSOUND pDS;
|
||
DSCAPS dscaps;
|
||
BOOL fEmulFound;
|
||
WAVEFORMATEX wfPCM8K16 = {WAVE_FORMAT_PCM,1,8000,16000,2,16,0};
|
||
WAVEOUTCAPS waveOutCaps;
|
||
|
||
if (!m_fInitialized)
|
||
Initialize(); // get the list of DS devices
|
||
|
||
if (!m_pDSInfoList)
|
||
return DPR_CANT_OPEN_DEV;
|
||
else if (waveId == WAVE_MAPPER || waveOutGetNumDevs()==1) {
|
||
// we want the default or there is only one DS device, take the easy way out
|
||
*pGuid = GUID_NULL;
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
// try using the IKsProperty interface on a DirectSoundPrivate object
|
||
// to find out what GUID maps to the waveId in question
|
||
// Only likely to work on Win98 and NT 5.
|
||
ZeroMemory(&waveOutCaps, sizeof(WAVEOUTCAPS));
|
||
mmr = waveOutGetDevCaps(waveId, &waveOutCaps, sizeof(WAVEOUTCAPS));
|
||
if (mmr == MMSYSERR_NOERROR)
|
||
{
|
||
hr = DsprvGetWaveDeviceMapping(waveOutCaps.szPname, FALSE, pGuid);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
return hr;
|
||
}
|
||
// if we failed to make a mapping, fall through to the old code path
|
||
}
|
||
|
||
|
||
mmr = waveOutOpen(&hWaveOut, waveId,
|
||
&wfPCM8K16,
|
||
0, 0, CALLBACK_NULL);
|
||
if (mmr != MMSYSERR_NOERROR) {
|
||
DEBUGMSG(ZONE_DP,("MapWaveIdToGuid - cannot open wave(%d)\n", waveId));
|
||
return DPR_CANT_OPEN_DEV;
|
||
}
|
||
// now open all the DS devices in turn
|
||
for (pDSInfo = m_pDSInfoList; pDSInfo; pDSInfo = pDSInfo->pNext) {
|
||
hr = (*m_pDirectSoundCreate)(&pDSInfo->guid, &pDS, NULL);
|
||
if (hr != S_OK) {
|
||
pDSInfo->flags |= DSFLAG_ALLOCATED; // this is a candidate
|
||
} else {
|
||
pDSInfo->flags &= ~DSFLAG_ALLOCATED;
|
||
pDS->Release();
|
||
}
|
||
}
|
||
waveOutClose(hWaveOut);
|
||
hr = DPR_CANT_OPEN_DEV;
|
||
|
||
dscaps.dwSize = sizeof(dscaps);
|
||
fEmulFound = FALSE;
|
||
// try opening the DS devices that failed the first time
|
||
for (pDSInfo = m_pDSInfoList; pDSInfo; pDSInfo = pDSInfo->pNext) {
|
||
if (pDSInfo->flags & DSFLAG_ALLOCATED) {
|
||
hr = (*m_pDirectSoundCreate)(&pDSInfo->guid, &pDS, NULL);
|
||
if (hr == S_OK) {
|
||
*pGuid = pDSInfo->guid;
|
||
// get dsound capabilities.
|
||
// NOTE: consider putting the caps in DSINFO if its used often
|
||
pDS->GetCaps(&dscaps);
|
||
pDS->Release();
|
||
DEBUGMSG(ZONE_DP,("mapped waveid %d to DS device(%s)\n", waveId, pDSInfo->pszDescription));
|
||
if (dscaps.dwFlags & DSCAPS_EMULDRIVER)
|
||
fEmulFound = TRUE; // keep looking in case there's also a native driver
|
||
else
|
||
break; // native DS driver. Look no further
|
||
|
||
}
|
||
}
|
||
}
|
||
if (fEmulFound)
|
||
hr = S_OK;
|
||
|
||
if (hr != S_OK) {
|
||
DEBUGMSG(ZONE_DP,("Cant map id %d to DSound guid!\n", waveId));
|
||
hr = DPR_CANT_OPEN_DEV;
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
HRESULT
|
||
DirectSoundMgr::Instance(LPGUID pDeviceGuid,LPDIRECTSOUND *ppDS, HWND hwnd, WAVEFORMATEX *pwf)
|
||
{
|
||
DSINFO *pDSInfo = m_pDSInfoList;
|
||
HRESULT hr;
|
||
DSBUFFERDESC dsBufDesc;
|
||
FX_ENTRY("DirectSoundInstance");
|
||
|
||
if (pDeviceGuid == NULL)
|
||
pDeviceGuid = &myNullGuid;
|
||
// search for the Guid in the list
|
||
*ppDS = NULL;
|
||
|
||
if (!m_fInitialized)
|
||
Initialize();
|
||
|
||
while (pDSInfo) {
|
||
if (pDSInfo->guid == *pDeviceGuid)
|
||
break;
|
||
pDSInfo = pDSInfo->pNext;
|
||
}
|
||
ASSERT (pDSInfo);
|
||
|
||
if (!pDSInfo || !pDSInfo->pDS) {
|
||
// need to create DS object
|
||
PlaySound(NULL,NULL,0); // hack to stop system sounds
|
||
|
||
hr = (*m_pDirectSoundCreate)((*pDeviceGuid==GUID_NULL ? NULL: pDeviceGuid), ppDS, NULL);
|
||
//set priority cooperative level, so we can set the format of the primary buffer.
|
||
if (hr == S_OK && (hr = (*ppDS)->SetCooperativeLevel(hwnd,DSSCL_PRIORITY)) == S_OK)
|
||
{
|
||
if (!pDSInfo) {
|
||
DEBUGMSG(ZONE_DP,("%s: GUID not in List!\n",_fx_));
|
||
// BUGBUG: remove this block. Enumerate should have created the entry (except for NULL guid?)
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
pDSInfo = new DSINFO;
|
||
if (pDSInfo) {
|
||
pDSInfo->uRef = 0;
|
||
pDSInfo->guid = *pDeviceGuid;
|
||
pDSInfo->pNext = m_pDSInfoList;
|
||
m_pDSInfoList = pDSInfo;
|
||
} else {
|
||
(*ppDS)->Release();
|
||
return DPR_OUT_OF_MEMORY;
|
||
}
|
||
|
||
}
|
||
pDSInfo->pDS = *ppDS;
|
||
++pDSInfo->uRef;
|
||
// Create a primary buffer only to set the format
|
||
// (what if its already set?)
|
||
ZeroMemory(&dsBufDesc,sizeof(dsBufDesc));
|
||
dsBufDesc.dwSize = sizeof(dsBufDesc);
|
||
dsBufDesc.dwFlags = DSBCAPS_PRIMARYBUFFER|DSBCAPS_STICKYFOCUS;
|
||
// STICKYFOCUS flags is supposed to preserve the format
|
||
// when the app is not in-focus.
|
||
hr = pDSInfo->pDS->CreateSoundBuffer(&dsBufDesc,&pDSInfo->pDSPrimaryBuf,NULL);
|
||
if (hr == S_OK && pwf) {
|
||
pDSInfo->pDSPrimaryBuf->SetFormat(pwf);
|
||
} else {
|
||
DEBUGMSG (ZONE_DP, ("%s: Create PrimarySoundBuffer failed, hr=0x%lX\r\n", _fx_, hr));
|
||
hr = S_OK; // Non fatal error
|
||
}
|
||
//DEBUGMSG(ZONE_DP, ("%s: Created Direct Sound object (%s)\n", _fx_,pDSInfo->pszDescription));
|
||
} else {
|
||
DEBUGMSG(ZONE_DP, ("%s: Could not create DS object (%s)\n", _fx_,pDSInfo->pszDescription));
|
||
|
||
}
|
||
LOG((LOGMSG_DSCREATE, hr));
|
||
} else {
|
||
*ppDS = pDSInfo->pDS;
|
||
++pDSInfo->uRef;
|
||
hr = S_OK;
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
HRESULT
|
||
DirectSoundMgr::ReleaseInstance(LPDIRECTSOUND pDS)
|
||
{
|
||
// deref the DS object and release it if necessary
|
||
DSINFO *pDSInfo = m_pDSInfoList;
|
||
|
||
while (pDSInfo) {
|
||
if (pDSInfo->pDS == pDS) {
|
||
ASSERT(pDSInfo->uRef > 0);
|
||
if (--pDSInfo->uRef == 0) {
|
||
ULONG uref;
|
||
if (pDSInfo->pDSPrimaryBuf) {
|
||
pDSInfo->pDSPrimaryBuf->Release();
|
||
pDSInfo->pDSPrimaryBuf = NULL;
|
||
}
|
||
uref = pDS->Release();
|
||
pDSInfo->pDS = 0;
|
||
LOG((LOGMSG_DSRELEASE, uref));
|
||
//DEBUGMSG(ZONE_DP, ("Release Direct Sound object (%s) uref=%d\n", pDSInfo->pszDescription, uref));
|
||
// dont bother freeing DSINFO. Its okay
|
||
// to keep it around till the process dies
|
||
}
|
||
break;
|
||
}
|
||
pDSInfo = pDSInfo->pNext;
|
||
}
|
||
return (pDSInfo ? S_OK : DPR_INVALID_PARAMETER);
|
||
}
|
||
|
||
|
||
void DSTimeout::TimeoutIndication()
|
||
{
|
||
ASSERT(m_pRDSStream);
|
||
m_pRDSStream->RecvTimeout();
|
||
}
|
||
|
||
|
||
HRESULT STDMETHODCALLTYPE RecvDSAudioStream::QueryInterface(REFIID iid, void **ppVoid)
|
||
{
|
||
// resolve duplicate inheritance to the SendMediaStream;
|
||
|
||
extern IID IID_IProperty;
|
||
|
||
if (iid == IID_IUnknown)
|
||
{
|
||
*ppVoid = (IUnknown*)((RecvMediaStream*)this);
|
||
}
|
||
else if (iid == IID_IMediaChannel)
|
||
{
|
||
*ppVoid = (IMediaChannel*)((RecvMediaStream *)this);
|
||
}
|
||
else if (iid == IID_IAudioChannel)
|
||
{
|
||
*ppVoid = (IAudioChannel*)this;
|
||
}
|
||
else if (iid == IID_IProperty)
|
||
{
|
||
*ppVoid = NULL;
|
||
ERROR_OUT(("Don't QueryInterface for IID_IProperty, use IMediaChannel"));
|
||
return E_NOINTERFACE;
|
||
}
|
||
else
|
||
{
|
||
*ppVoid = NULL;
|
||
return E_NOINTERFACE;
|
||
}
|
||
AddRef();
|
||
|
||
return S_OK;
|
||
|
||
}
|
||
|
||
ULONG STDMETHODCALLTYPE RecvDSAudioStream::AddRef(void)
|
||
{
|
||
return InterlockedIncrement(&m_lRefCount);
|
||
}
|
||
|
||
ULONG STDMETHODCALLTYPE RecvDSAudioStream::Release(void)
|
||
{
|
||
LONG lRet;
|
||
|
||
lRet = InterlockedDecrement(&m_lRefCount);
|
||
|
||
if (lRet == 0)
|
||
{
|
||
delete this;
|
||
return 0;
|
||
}
|
||
|
||
else
|
||
return lRet;
|
||
|
||
}
|
||
|
||
|
||
|
||
HRESULT
|
||
RecvDSAudioStream::Initialize( DataPump *pDP)
|
||
{
|
||
HRESULT hr = DPR_OUT_OF_MEMORY;
|
||
DWORD dwFlags = DP_FLAG_ACM| DP_FLAG_DIRECTSOUND | DP_FLAG_HALF_DUPLEX | DP_FLAG_AUTO_SWITCH ;
|
||
MEDIACTRLINIT mcInit;
|
||
FX_ENTRY ("RecvDSAudioStream::Initialize")
|
||
|
||
InitializeCriticalSection(&m_crsAudQoS);
|
||
|
||
// enable Recv by default
|
||
m_DPFlags = dwFlags | DPFLAG_ENABLE_RECV;
|
||
// store a back pointer to the datapump container
|
||
m_pDP = pDP;
|
||
m_Net = NULL;
|
||
m_dwSrcSize = 0;
|
||
m_pIRTPRecv = NULL;
|
||
m_nFailCount = 0;
|
||
m_bJammed = FALSE;
|
||
m_bCanSignalOpen = TRUE;
|
||
|
||
|
||
|
||
// Initialize data (should be in constructor)
|
||
m_DSguid = GUID_NULL; // use default device
|
||
|
||
// Create decode audio filters
|
||
m_hStrmConv = NULL; // replaced by AcmFilter
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
m_pAudioFilter = new AcmFilter;
|
||
if (!m_pAudioFilter)
|
||
{
|
||
DEBUGMSG (ZONE_DP, ("%s: AcmManager new failed\r\n", _fx_));
|
||
goto FilterAllocError;
|
||
}
|
||
|
||
ZeroMemory (&m_StrmConvHdr, sizeof (ACMSTREAMHEADER));
|
||
|
||
|
||
// determine if the wave devices are available
|
||
if (waveOutGetNumDevs()) m_DPFlags |= DP_FLAG_PLAY_CAP;
|
||
|
||
|
||
m_DPFlags |= DPFLAG_INITIALIZED;
|
||
|
||
UPDATE_REPORT_ENTRY(g_prptSystemSettings, 1, REP_SYS_AUDIO_DSOUND);
|
||
RETAILMSG(("NAC: Audio Subsystem: DirectSound"));
|
||
|
||
return DPR_SUCCESS;
|
||
|
||
|
||
FilterAllocError:
|
||
if (m_pAudioFilter) delete m_pAudioFilter;
|
||
|
||
ERRORMESSAGE( ("%s: exit, hr=0x%lX\r\n", _fx_, hr));
|
||
|
||
return hr;
|
||
}
|
||
|
||
RecvDSAudioStream::~RecvDSAudioStream()
|
||
{
|
||
|
||
if (m_DPFlags & DPFLAG_INITIALIZED) {
|
||
m_DPFlags &= ~DPFLAG_INITIALIZED;
|
||
|
||
if (m_DPFlags & DPFLAG_CONFIGURED_RECV)
|
||
UnConfigure();
|
||
|
||
if (m_pIRTPRecv)
|
||
{
|
||
m_pIRTPRecv->Release();
|
||
m_pIRTPRecv = NULL;
|
||
}
|
||
|
||
if (m_pAudioFilter)
|
||
delete m_pAudioFilter;
|
||
|
||
m_pDP->RemoveMediaChannel(MCF_RECV|MCF_AUDIO, (IMediaChannel*)(RecvMediaStream*)this);
|
||
|
||
}
|
||
DeleteCriticalSection(&m_crsAudQoS);
|
||
}
|
||
|
||
extern UINT ChoosePacketSize(WAVEFORMATEX *pwf);
|
||
extern UINT g_MaxAudioDelayMs;
|
||
extern UINT g_MinWaveAudioDelayMs;
|
||
extern UINT g_MinDSEmulAudioDelayMs; // emulated DS driver delay
|
||
|
||
|
||
HRESULT STDMETHODCALLTYPE RecvDSAudioStream::Configure(
|
||
BYTE *pFormat,
|
||
UINT cbFormat,
|
||
BYTE *pChannelParams,
|
||
UINT cbParams,
|
||
IUnknown *pUnknown)
|
||
{
|
||
HRESULT hr=E_FAIL;
|
||
BOOL fRet;
|
||
DWORD dwMaxDecompressedSize;
|
||
UINT cbSamplesPerPkt;
|
||
DWORD dwPropVal;
|
||
DWORD dwFlags;
|
||
UINT uAudioCodec;
|
||
AUDIO_CHANNEL_PARAMETERS audChannelParams;
|
||
UINT ringSize = MAX_RXRING_SIZE;
|
||
WAVEFORMATEX *pwfRecv;
|
||
UINT maxRingSamples;
|
||
MMRESULT mmr;
|
||
|
||
FX_ENTRY ("RecvDSAudioStream::Configure")
|
||
|
||
// m_Net = pNet;
|
||
|
||
|
||
if (m_DPFlags & DPFLAG_STARTED_RECV)
|
||
{
|
||
return DPR_IO_PENDING; // anything better to return
|
||
}
|
||
|
||
if (m_DPFlags & DPFLAG_CONFIGURED_RECV)
|
||
{
|
||
DEBUGMSG(ZONE_DP, ("Stream Re-Configuration - calling UnConfigure"));
|
||
UnConfigure(); // a re-configure will release the RTP object, need to call SetNetworkInterface again
|
||
}
|
||
|
||
|
||
if ((NULL == pFormat) ||
|
||
(NULL == pChannelParams) ||
|
||
(cbParams != sizeof(audChannelParams)) ||
|
||
(cbFormat < sizeof(WAVEFORMATEX)) )
|
||
|
||
{
|
||
return DPR_INVALID_PARAMETER;
|
||
}
|
||
|
||
audChannelParams = *(AUDIO_CHANNEL_PARAMETERS *)pChannelParams;
|
||
pwfRecv = (WAVEFORMATEX *)pFormat;
|
||
|
||
if (! (m_DPFlags & DPFLAG_INITIALIZED))
|
||
return DPR_OUT_OF_MEMORY; //BUGBUG: return proper error;
|
||
|
||
// if (m_Net)
|
||
// {
|
||
// hr = m_Net->QueryInterface(IID_IRTPRecv, (void **)&m_pIRTPRecv);
|
||
// if (!SUCCEEDED(hr))
|
||
// return hr;
|
||
// }
|
||
|
||
AcmFilter::SuggestDecodeFormat(pwfRecv, &m_fDevRecv);
|
||
|
||
UPDATE_REPORT_ENTRY(g_prptCallParameters, pwfRecv->wFormatTag, REP_RECV_AUDIO_FORMAT);
|
||
UPDATE_REPORT_ENTRY(g_prptCallParameters, pwfRecv->nSamplesPerSec, REP_RECV_AUDIO_SAMPLING);
|
||
UPDATE_REPORT_ENTRY(g_prptCallParameters, pwfRecv->nAvgBytesPerSec*8, REP_RECV_AUDIO_BITRATE);
|
||
RETAILMSG(("NAC: Audio Recv Format: %s", (pwfRecv->wFormatTag == 66) ? "G723.1" : (pwfRecv->wFormatTag == 112) ? "LHCELP" : (pwfRecv->wFormatTag == 113) ? "LHSB08" : (pwfRecv->wFormatTag == 114) ? "LHSB12" : (pwfRecv->wFormatTag == 115) ? "LHSB16" : (pwfRecv->wFormatTag == 6) ? "MSALAW" : (pwfRecv->wFormatTag == 7) ? "MSULAW" : (pwfRecv->wFormatTag == 130) ? "MSRT24" : "??????"));
|
||
RETAILMSG(("NAC: Audio Recv Sampling Rate (Hz): %ld", pwfRecv->nSamplesPerSec));
|
||
RETAILMSG(("NAC: Audio Recv Bitrate (w/o network overhead - bps): %ld", pwfRecv->nAvgBytesPerSec*8));
|
||
// note that parameters such as samples/packet are channel specific
|
||
|
||
cbSamplesPerPkt = audChannelParams.ns_params.wFrameSize
|
||
*audChannelParams.ns_params.wFramesPerPkt;
|
||
|
||
// turn on receive silence detection only if the sender is not using
|
||
// silence suppression
|
||
if (!audChannelParams.ns_params.UseSilenceDet)
|
||
m_DPFlags |= DP_FLAG_AUTO_SILENCE_DETECT;
|
||
else
|
||
m_DPFlags &= ~DP_FLAG_AUTO_SILENCE_DETECT;
|
||
UPDATE_REPORT_ENTRY(g_prptCallParameters, cbSamplesPerPkt, REP_RECV_AUDIO_PACKET);
|
||
RETAILMSG(("NAC: Audio Recv Packetization (ms/packet): %ld", pwfRecv->nSamplesPerSec ? cbSamplesPerPkt * 1000UL / pwfRecv->nSamplesPerSec : 0));
|
||
INIT_COUNTER_MAX(g_pctrAudioReceiveBytes, (pwfRecv->nAvgBytesPerSec * 8 + pwfRecv->nSamplesPerSec * (sizeof(RTP_HDR) + IP_HEADER_SIZE + UDP_HEADER_SIZE) / cbSamplesPerPkt) << 3);
|
||
|
||
|
||
// make the ring buffer size large enought to hold 4 seconds of audio
|
||
// This seems to be suitable for congested networks, in which
|
||
// packets can get delayed and them for many to suddelnly arrive at once
|
||
maxRingSamples = (pwfRecv->nSamplesPerSec * MIN_DSBUF_SIZE)/1000;
|
||
|
||
|
||
// describe the DirectSound buffer
|
||
|
||
ZeroMemory(&m_DSBufDesc,sizeof(m_DSBufDesc));
|
||
m_DSBufDesc.dwSize = sizeof (m_DSBufDesc);
|
||
m_DSBufDesc.dwFlags = DSBCAPS_CTRLVOLUME | DSBCAPS_GLOBALFOCUS | DSBCAPS_GETCURRENTPOSITION2;
|
||
m_DSBufDesc.dwBufferBytes = maxRingSamples * (m_fDevRecv.wBitsPerSample/8);
|
||
m_DSBufDesc.dwReserved = 0;
|
||
m_DSBufDesc.lpwfxFormat = &m_fDevRecv;
|
||
|
||
m_pDS = NULL;
|
||
m_pDSBuf = NULL;
|
||
|
||
|
||
// Initialize the recv-stream filter manager object
|
||
dwMaxDecompressedSize = cbSamplesPerPkt * (m_fDevRecv.nBlockAlign);
|
||
|
||
|
||
mmr = m_pAudioFilter->Open(pwfRecv, &m_fDevRecv);
|
||
if (mmr != 0)
|
||
{
|
||
DEBUGMSG (ZONE_DP, ("%s: AcmFilter->Open failed, mmr=%d\r\n", _fx_, mmr));
|
||
hr = DPR_CANT_OPEN_CODEC;
|
||
goto RecvFilterInitError;
|
||
}
|
||
|
||
|
||
// set up the decode buffer
|
||
m_pAudioFilter->SuggestSrcSize(dwMaxDecompressedSize, &m_dwSrcSize);
|
||
|
||
ZeroMemory (&m_StrmConvHdr, sizeof (ACMSTREAMHEADER));
|
||
m_StrmConvHdr.cbStruct = sizeof (ACMSTREAMHEADER);
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
m_StrmConvHdr.pbSrc = new BYTE[m_dwSrcSize];
|
||
m_StrmConvHdr.cbSrcLength = m_dwSrcSize; // may change for variable bit rate codecs
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
m_StrmConvHdr.pbDst = new BYTE[dwMaxDecompressedSize];
|
||
m_StrmConvHdr.cbDstLength = dwMaxDecompressedSize;
|
||
|
||
mmr = m_pAudioFilter->PrepareHeader(&m_StrmConvHdr);
|
||
if (mmr != MMSYSERR_NOERROR)
|
||
{
|
||
DEBUGMSG (ZONE_DP, ("%s: AcmFilter->Open failed, mmr=%d\r\n", _fx_, mmr));
|
||
hr = DPR_CANT_OPEN_CODEC;
|
||
goto RecvFilterInitError;
|
||
}
|
||
|
||
// Initialize the recv stream
|
||
m_BufSizeT = BYTESTOSAMPLES(m_DSBufDesc.dwBufferBytes);
|
||
m_fEmpty = TRUE;
|
||
|
||
m_MinDelayT = 0;
|
||
m_MaxDelayT = g_MaxAudioDelayMs * m_fDevRecv.nSamplesPerSec /1000;
|
||
m_ArrT = m_ArrivalT0 = 0;
|
||
m_ScaledAvgVarDelay = 0;
|
||
|
||
m_DelayT = m_MinDelayT;
|
||
|
||
m_SilenceDurationT = 0;
|
||
|
||
|
||
InitAudioFlowspec(&m_flowspec, pwfRecv, m_dwSrcSize);
|
||
|
||
m_DPFlags |= DPFLAG_CONFIGURED_RECV;
|
||
|
||
return DPR_SUCCESS;
|
||
|
||
RecvFilterInitError:
|
||
if (m_pIRTPRecv)
|
||
{
|
||
m_pIRTPRecv->Release();
|
||
m_pIRTPRecv = NULL;
|
||
}
|
||
|
||
m_pAudioFilter->Close();
|
||
|
||
delete [] m_StrmConvHdr.pbSrc;
|
||
delete [] m_StrmConvHdr.pbDst;
|
||
m_StrmConvHdr.pbSrc=NULL;
|
||
m_StrmConvHdr.pbDst = NULL;
|
||
|
||
|
||
ERRORMESSAGE(("%s: failed, hr=0%u\r\n", _fx_, hr));
|
||
return hr;
|
||
}
|
||
|
||
|
||
void RecvDSAudioStream::UnConfigure()
|
||
{
|
||
|
||
if ((m_DPFlags & DPFLAG_CONFIGURED_RECV))
|
||
{
|
||
Stop();
|
||
// Close the RTP state if its open
|
||
m_Net = NULL;
|
||
|
||
// release DS buffer and DS object
|
||
//ReleaseDSBuffer();
|
||
ASSERT(!m_pDSBuf); // released in StopRecv()
|
||
|
||
// Close the filters
|
||
m_StrmConvHdr.cbSrcLength = m_dwSrcSize;
|
||
m_pAudioFilter->UnPrepareHeader(&m_StrmConvHdr);
|
||
m_pAudioFilter->Close();
|
||
|
||
delete [] m_StrmConvHdr.pbSrc;
|
||
delete [] m_StrmConvHdr.pbDst;
|
||
m_StrmConvHdr.pbSrc=NULL;
|
||
m_StrmConvHdr.pbDst = NULL;
|
||
|
||
m_nFailCount = 0;
|
||
m_bJammed = FALSE;
|
||
m_bCanSignalOpen = TRUE;
|
||
|
||
// Close the receive streams
|
||
//m_RecvStream->Destroy();
|
||
m_DPFlags &= ~(DPFLAG_CONFIGURED_RECV);
|
||
}
|
||
}
|
||
|
||
|
||
HRESULT
|
||
RecvDSAudioStream::Start()
|
||
{
|
||
HRESULT hr;
|
||
IMediaChannel *pISendAudio;
|
||
BOOL fStoppedRecording;
|
||
FX_ENTRY ("RecvDSAudioStream::Start");
|
||
|
||
if (m_DPFlags & DPFLAG_STARTED_RECV)
|
||
return DPR_SUCCESS;
|
||
// TODO: remove this check once audio UI calls the IComChan PAUSE_RECV prop
|
||
if (!(m_DPFlags & DPFLAG_ENABLE_RECV))
|
||
return DPR_SUCCESS;
|
||
|
||
if ((!(m_DPFlags & DPFLAG_CONFIGURED_RECV)) || (!m_pIRTPRecv))
|
||
return DPR_NOT_CONFIGURED;
|
||
|
||
ASSERT(!m_hRenderingThread );
|
||
m_ThreadFlags &= ~(DPTFLAG_STOP_PLAY|DPTFLAG_STOP_RECV);
|
||
|
||
SetFlowSpec();
|
||
|
||
pISendAudio = NULL;
|
||
fStoppedRecording = FALSE;
|
||
if (!(m_DPFlags & DP_FLAG_HALF_DUPLEX))
|
||
{
|
||
// make sure the recording device is closed before creating the DS object
|
||
// Why ? Because SoundBlaster either sounds lousy or doesnt work at all if
|
||
// you open waveIn before waveOut or DirectSound.
|
||
m_pDP->GetMediaChannelInterface(MCF_AUDIO|MCF_SEND, &pISendAudio);
|
||
if (pISendAudio && pISendAudio->GetState()== MSSTATE_STARTED
|
||
&& pISendAudio->Stop() == S_OK)
|
||
{
|
||
fStoppedRecording = TRUE;
|
||
DEBUGMSG(ZONE_DP,("%s:Stopped Recording\n",_fx_));
|
||
}
|
||
}
|
||
|
||
// Start receive thread. This will create the DSound object
|
||
m_pDP->StartReceiving(this);
|
||
|
||
if (pISendAudio) {
|
||
if (fStoppedRecording)
|
||
pISendAudio->Start();
|
||
pISendAudio->Release();
|
||
}
|
||
|
||
m_DPFlags |= DPFLAG_STARTED_RECV;
|
||
return DPR_SUCCESS;
|
||
}
|
||
|
||
// LOOK: Identical to RecvVideoStream version.
|
||
HRESULT
|
||
RecvDSAudioStream::Stop()
|
||
{
|
||
|
||
|
||
FX_ENTRY ("RecvDSAudioStream::Stop");
|
||
|
||
if(!(m_DPFlags & DPFLAG_STARTED_RECV))
|
||
{
|
||
return DPR_SUCCESS;
|
||
}
|
||
|
||
m_ThreadFlags = m_ThreadFlags |
|
||
DPTFLAG_STOP_RECV | DPTFLAG_STOP_PLAY ;
|
||
|
||
// delink from receive thread
|
||
m_pDP->StopReceiving(this);
|
||
|
||
if (m_pDSBuf)
|
||
m_pDSBuf->Stop();
|
||
|
||
//This is per channel, but the variable is "DPFlags"
|
||
m_DPFlags &= ~DPFLAG_STARTED_RECV;
|
||
|
||
return DPR_SUCCESS;
|
||
}
|
||
|
||
// IProperty::GetProperty / SetProperty
|
||
// (DataPump::MediaChannel::GetProperty)
|
||
// Properties of the MediaChannel. Supports properties for both audio
|
||
// and video channels.
|
||
|
||
STDMETHODIMP
|
||
RecvDSAudioStream::GetProperty(
|
||
DWORD prop,
|
||
PVOID pBuf,
|
||
LPUINT pcbBuf
|
||
)
|
||
{
|
||
HRESULT hr = DPR_SUCCESS;
|
||
RTP_STATS RTPStats;
|
||
DWORD dwValue;
|
||
UINT len = sizeof(DWORD); // most props are DWORDs
|
||
|
||
if (!pBuf || *pcbBuf < len)
|
||
{
|
||
*pcbBuf = len;
|
||
return DPR_INVALID_PARAMETER;
|
||
}
|
||
|
||
switch (prop)
|
||
{
|
||
case PROP_RECV_AUDIO_STRENGTH:
|
||
{
|
||
return GetSignalLevel((UINT*)pBuf);
|
||
}
|
||
|
||
#ifdef OLDSTUFF
|
||
case PROP_NET_RECV_STATS:
|
||
if (m_Net && *pcbBuf >= sizeof(RTP_STATS))
|
||
{
|
||
m_Net->GetRecvStats((RTP_STATS *)pBuf);
|
||
*pcbBuf = sizeof(RTP_STATS);
|
||
} else
|
||
hr = DPR_INVALID_PROP_VAL;
|
||
|
||
break;
|
||
#endif
|
||
//case PROP_VOLUME:
|
||
|
||
case PROP_DUPLEX_TYPE:
|
||
|
||
if(m_DPFlags & DP_FLAG_HALF_DUPLEX)
|
||
*(DWORD*)pBuf = DUPLEX_TYPE_HALF;
|
||
else
|
||
*(DWORD*)pBuf = DUPLEX_TYPE_FULL;
|
||
break;
|
||
|
||
case PROP_WAVE_DEVICE_TYPE:
|
||
*(DWORD*)pBuf = m_DPFlags & DP_MASK_WAVE_DEVICE;
|
||
break;
|
||
case PROP_PLAY_ON:
|
||
*(DWORD *)pBuf = (m_ThreadFlags & DPFLAG_ENABLE_RECV)!=0;
|
||
break;
|
||
case PROP_PLAYBACK_DEVICE:
|
||
*(DWORD *)pBuf = m_RenderingDevice;
|
||
break;
|
||
|
||
case PROP_VIDEO_AUDIO_SYNC:
|
||
*(DWORD*)pBuf = ((m_DPFlags & DPFLAG_AV_SYNC) != 0);
|
||
break;
|
||
|
||
default:
|
||
hr = DPR_INVALID_PROP_ID;
|
||
break;
|
||
}
|
||
return hr;
|
||
}
|
||
|
||
|
||
// low order word is the signal strength
|
||
// high order work contains bits to indicate status
|
||
// (0x01 - transmitting)
|
||
// (0x02 - audio device is jammed)
|
||
STDMETHODIMP RecvDSAudioStream::GetSignalLevel(UINT *pSignalStrength)
|
||
{
|
||
DWORD dwLevel;
|
||
DWORD dwJammed;
|
||
|
||
if ((!(m_DPFlags & DPFLAG_STARTED_RECV)) || (m_fEmpty) ||
|
||
(m_ThreadFlags & DPTFLAG_PAUSE_RECV) )
|
||
{
|
||
dwLevel = 0;
|
||
}
|
||
else
|
||
{
|
||
dwLevel = GetSignalStrength();
|
||
dwLevel = LogScale[(dwLevel >> 8) & 0x00ff];
|
||
|
||
if (m_bJammed)
|
||
{
|
||
dwLevel |= (2 << 16);
|
||
}
|
||
|
||
dwLevel |= (1 << 16);
|
||
}
|
||
*pSignalStrength = dwLevel;
|
||
return S_OK;
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
DWORD
|
||
RecvDSAudioStream::GetSignalStrength()
|
||
{
|
||
BYTE bMax, bMin, *pb;
|
||
short sMax, sMin, *ps;
|
||
UINT cbSize;
|
||
DWORD dwMaxStrength = 0;
|
||
cbSize = m_StrmConvHdr.cbDstLengthUsed;
|
||
if (cbSize==0)
|
||
return 0;
|
||
switch (m_fDevRecv.wBitsPerSample)
|
||
{
|
||
case 8: // unsigned char
|
||
|
||
pb = (PBYTE) (m_StrmConvHdr.pbDst);
|
||
|
||
bMax = 0;
|
||
bMin = 255;
|
||
|
||
for ( ; cbSize; cbSize--, pb++)
|
||
{
|
||
if (*pb > bMax) bMax = *pb;
|
||
if (*pb < bMin) bMin = *pb;
|
||
}
|
||
|
||
// 2^9 <-- 2^16 / 2^7
|
||
dwMaxStrength = ((DWORD) (bMax - bMin)) << 8;
|
||
break;
|
||
|
||
case 16: // (signed) short
|
||
|
||
ps = (short *) (m_StrmConvHdr.pbDst);
|
||
cbSize = m_StrmConvHdr.cbDstLengthUsed;
|
||
|
||
sMax = sMin = 0;
|
||
|
||
for (cbSize >>= 1; cbSize; cbSize--, ps++)
|
||
{
|
||
if (*ps > sMax) sMax = *ps;
|
||
if (*ps < sMin) sMin = *ps;
|
||
}
|
||
|
||
dwMaxStrength = (DWORD) (sMax - sMin); // drop sign bit
|
||
break;
|
||
|
||
}
|
||
return dwMaxStrength;
|
||
}
|
||
|
||
|
||
STDMETHODIMP
|
||
RecvDSAudioStream::SetProperty(
|
||
DWORD prop,
|
||
PVOID pBuf,
|
||
UINT cbBuf
|
||
)
|
||
{
|
||
DWORD dw;
|
||
HRESULT hr = S_OK;
|
||
|
||
if (cbBuf < sizeof (DWORD))
|
||
return DPR_INVALID_PARAMETER;
|
||
|
||
switch (prop)
|
||
{
|
||
//case PROP_VOLUME:
|
||
|
||
|
||
case PROP_DUPLEX_TYPE:
|
||
ASSERT(0); // dead code for this case type;
|
||
break;
|
||
|
||
case DP_PROP_DUPLEX_TYPE:
|
||
// internal version, called by DataPump::SetDuplexMode() after ensuring streams are stopped
|
||
dw = *(DWORD *)pBuf;
|
||
if (dw & DP_FLAG_HALF_DUPLEX)
|
||
m_DPFlags |= DP_FLAG_HALF_DUPLEX;
|
||
else
|
||
m_DPFlags &= ~DP_FLAG_HALF_DUPLEX;
|
||
break;
|
||
|
||
|
||
case PROP_PLAY_ON:
|
||
{
|
||
|
||
if (*(DWORD *)pBuf) // unmute
|
||
{
|
||
m_ThreadFlags &= ~DPTFLAG_PAUSE_RECV;
|
||
}
|
||
else // mute
|
||
{
|
||
m_ThreadFlags |= DPTFLAG_PAUSE_RECV;
|
||
}
|
||
|
||
// DWORD flag = DPFLAG_ENABLE_RECV;
|
||
// if (*(DWORD *)pBuf) {
|
||
// m_DPFlags |= flag; // set the flag
|
||
// hr = Start();
|
||
// }
|
||
// else
|
||
// {
|
||
// m_DPFlags &= ~flag; // clear the flag
|
||
// hr = Stop();
|
||
// }
|
||
|
||
RETAILMSG(("NAC: RecvAudioStream: %s", *(DWORD*)pBuf ? "Enabling":"Disabling"));
|
||
break;
|
||
}
|
||
case PROP_PLAYBACK_DEVICE:
|
||
m_RenderingDevice = *(DWORD*)pBuf;
|
||
RETAILMSG(("NAC: Setting default playback device to %d", m_RenderingDevice));
|
||
if (m_RenderingDevice != WAVE_MAPPER)
|
||
hr = DirectSoundMgr::MapWaveIdToGuid(m_RenderingDevice,&m_DSguid);
|
||
break;
|
||
|
||
case PROP_VIDEO_AUDIO_SYNC:
|
||
if (*(DWORD *)pBuf)
|
||
m_DPFlags |= DPFLAG_AV_SYNC;
|
||
else
|
||
m_DPFlags &= ~DPFLAG_AV_SYNC;
|
||
break;
|
||
|
||
default:
|
||
return DPR_INVALID_PROP_ID;
|
||
break;
|
||
}
|
||
return hr;
|
||
}
|
||
|
||
HRESULT
|
||
RecvDSAudioStream::GetCurrentPlayNTPTime(NTP_TS *pNtpTime)
|
||
{
|
||
DWORD rtpTime;
|
||
#ifdef OLDSTUFF
|
||
if ((m_DPFlags & DPFLAG_STARTED_RECV) && m_fReceiving) {
|
||
if (m_Net->RTPtoNTP(m_PlaybackTimestamp,pNtpTime))
|
||
return S_OK;
|
||
}
|
||
#endif
|
||
return 0xff; // return proper error
|
||
|
||
}
|
||
|
||
BOOL RecvDSAudioStream::IsEmpty() {
|
||
// check if anything in DSBuffer or in decode buffer
|
||
return (m_fEmpty && !(m_StrmConvHdr.dwDstUser & BUFFER_RECEIVED));
|
||
}
|
||
|
||
/*
|
||
Called by the recv thread to setup the stream for receiving.
|
||
Post the initial recv buffer(s). Subsequently, the buffers are posted
|
||
in the RTPRecvCallback()
|
||
*/
|
||
HRESULT
|
||
RecvDSAudioStream::StartRecv(HWND hWnd)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
DWORD dwPropVal = 0;
|
||
FX_ENTRY ("RecvDSAudioStream::StartRecv");
|
||
|
||
if ((!(m_ThreadFlags & DPTFLAG_STOP_RECV) ) && (m_DPFlags & DPFLAG_CONFIGURED_RECV)){
|
||
if (!(m_DPFlags & DP_FLAG_HALF_DUPLEX) && !m_pDSBuf) {
|
||
// Create the DS object only if its full-duplex
|
||
// In the half-duplex case the DSbuffer is created
|
||
// when the first packet is received
|
||
// only reason its here is so that SetDuplexMode can take effect right away
|
||
// BUGBUG: opening waveIn before DS causes death of the waveOut on Memphis!!
|
||
hr = CreateDSBuffer();
|
||
|
||
if (hr != S_OK) {
|
||
DEBUGMSG (ZONE_DP, ("%s: CreateSoundBuffer create failed, hr=0x%lX\r\n", _fx_, hr));
|
||
return hr;
|
||
}
|
||
}
|
||
if (m_pDSBuf)
|
||
hr = m_pDSBuf->Play(0,0,DSBPLAY_LOOPING);
|
||
|
||
// m_RecvFilter->GetProp (FM_PROP_SRC_SIZE, &dwPropVal);
|
||
//hr = m_Net->SetRecvNotification(&RTPRecvDSCallback, (DWORD)this, 2, dwPropVal, hWnd); // for WS1 only
|
||
hr =m_pIRTPRecv->SetRecvNotification(&RTPRecvCallback,(DWORD_PTR)this, 2);
|
||
|
||
|
||
}
|
||
return hr;
|
||
}
|
||
|
||
/*
|
||
Called by the recv thread to suspend receiving on this RTP session
|
||
If there are outstanding receive buffers they have to be recovered
|
||
*/
|
||
|
||
HRESULT
|
||
RecvDSAudioStream::StopRecv()
|
||
{
|
||
// dont recv on this stream
|
||
m_pIRTPRecv->CancelRecvNotification();
|
||
|
||
// cancel any pending timeout. (its okay if it wasnt scheduled )
|
||
m_pDP->m_RecvTimer.CancelTimeout(&m_TimeoutObj);
|
||
|
||
// Release DirectSound object
|
||
ReleaseDSBuffer();
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
/*
|
||
Create a DirectSound object and a DirectSound secondary buffer.
|
||
This routine is called after the stream is configured, so the wave format has been set
|
||
and the DSBUFFERDESC struct has been initialized.
|
||
*/
|
||
HRESULT
|
||
RecvDSAudioStream::CreateDSBuffer()
|
||
{
|
||
HRESULT hr;
|
||
HWAVEOUT hwo=NULL;
|
||
DSCAPS dscaps;
|
||
FX_ENTRY ("RecvDSAudioStream::CreateDSBuffer");
|
||
|
||
ASSERT(!m_pDSBuf);
|
||
if (m_DPFlags & DP_FLAG_HALF_DUPLEX) {
|
||
DWORD dwStatus;
|
||
// Got to take the half duplex event
|
||
// BUGBUG: this method wont cut it if there is more than one send and one recv stream
|
||
dwStatus = WaitForSingleObject(g_hEventHalfDuplex, 0);
|
||
if (dwStatus != WAIT_OBJECT_0)
|
||
return DPR_CANT_OPEN_DEV;
|
||
}
|
||
// Stop any high level ("PlaySound()") usage of wave device.
|
||
|
||
// Create the direct sound object (if necessary)
|
||
hr = DirectSoundMgr::Instance(m_RenderingDevice==WAVE_MAPPER ? NULL: &m_DSguid, &m_pDS, m_pDP->m_hAppWnd, &m_fDevRecv);
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
hr = m_pDS->CreateSoundBuffer(&m_DSBufDesc,&m_pDSBuf,NULL);
|
||
if (hr == DSERR_INVALIDPARAM)
|
||
{
|
||
// if global focus (DX3) is not supported, try sticky focus
|
||
m_DSBufDesc.dwFlags ^= (DSBCAPS_GLOBALFOCUS|DSBCAPS_STICKYFOCUS);
|
||
hr = m_pDS->CreateSoundBuffer(&m_DSBufDesc,&m_pDSBuf,NULL);
|
||
}
|
||
m_PlayPosT = 0; // DS play position is initially at the start of the buffer
|
||
|
||
if (hr != S_OK)
|
||
{
|
||
DEBUGMSG (ZONE_DP, ("%s: CreateSoundBuffer create failed, hr=0x%lX\r\n", _fx_, hr));
|
||
|
||
m_nFailCount++;
|
||
if (m_nFailCount == MAX_FAILCOUNT)
|
||
{
|
||
m_pDP->StreamEvent(MCF_RECV, MCF_AUDIO, STREAM_EVENT_DEVICE_FAILURE, 0);
|
||
m_bJammed = TRUE;
|
||
m_bCanSignalOpen = TRUE;
|
||
}
|
||
}
|
||
|
||
dscaps.dwSize = sizeof(dscaps);
|
||
dscaps.dwFlags = 0;
|
||
m_pDS->GetCaps(&dscaps); // get DirectSound object attributes
|
||
m_DSFlags = dscaps.dwFlags;
|
||
|
||
if (m_DSFlags & DSCAPS_EMULDRIVER)
|
||
{
|
||
// use g_MinDSEmulAudioDelay since this is the emulated driver
|
||
m_MinDelayT = (m_fDevRecv.nSamplesPerSec * g_MinDSEmulAudioDelayMs) / 1000;
|
||
m_DelayT = m_MinDelayT;
|
||
};
|
||
}
|
||
|
||
else
|
||
{
|
||
DEBUGMSG (ZONE_DP, ("%s: DirectSound create failed, hr=0x%lX\r\n", _fx_, hr));
|
||
|
||
m_nFailCount++;
|
||
if (m_nFailCount == MAX_FAILCOUNT)
|
||
{
|
||
m_pDP->StreamEvent(MCF_RECV, MCF_AUDIO, STREAM_EVENT_DEVICE_FAILURE, 0);
|
||
m_bJammed = TRUE;
|
||
m_bCanSignalOpen = TRUE;
|
||
}
|
||
}
|
||
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
if (m_DPFlags & DPFLAG_STARTED_RECV)
|
||
{
|
||
m_pDSBuf->Play(0,0,DSBPLAY_LOOPING);
|
||
}
|
||
|
||
if (m_bCanSignalOpen)
|
||
{
|
||
m_pDP->StreamEvent(MCF_RECV, MCF_AUDIO, STREAM_EVENT_DEVICE_OPEN, 0);
|
||
m_bCanSignalOpen = FALSE; // don't signal open condition anymore
|
||
}
|
||
|
||
m_bJammed = FALSE;
|
||
m_nFailCount = 0;
|
||
}
|
||
else
|
||
{
|
||
ReleaseDSBuffer();
|
||
}
|
||
return hr;
|
||
}
|
||
|
||
HRESULT
|
||
RecvDSAudioStream::ReleaseDSBuffer()
|
||
{
|
||
m_fEmpty = TRUE;
|
||
if (m_pDSBuf) {
|
||
ULONG uref;
|
||
uref = m_pDSBuf->Release();
|
||
m_pDSBuf = NULL;
|
||
//DEBUGMSG(ZONE_DP,("Releasing DirectSound buffer (%d)\n", uref));
|
||
}
|
||
if (m_pDS) {
|
||
DirectSoundMgr::ReleaseInstance(m_pDS);
|
||
m_pDS = NULL;
|
||
if (m_DPFlags & DP_FLAG_HALF_DUPLEX)
|
||
SetEvent(g_hEventHalfDuplex);
|
||
}
|
||
return S_OK;
|
||
|
||
}
|
||
|
||
HRESULT
|
||
RecvDSAudioStream::Decode(UCHAR *pData, UINT cbData)
|
||
{
|
||
MMRESULT mmr;
|
||
HRESULT hr=S_OK;
|
||
FX_ENTRY ("RecvDSAudioStream::Decode");
|
||
UINT uDstLength;
|
||
|
||
|
||
if (m_dwSrcSize < cbData)
|
||
{
|
||
DEBUGMSG (ZONE_DP, ("%s: RecvDSAudioStream::Decode failed - buffer larger than expected\r\n", _fx_));
|
||
return DPR_CONVERSION_FAILED;
|
||
}
|
||
|
||
CopyMemory(m_StrmConvHdr.pbSrc, pData, cbData);
|
||
m_StrmConvHdr.cbSrcLength = cbData;
|
||
mmr = m_pAudioFilter->Convert(&m_StrmConvHdr);
|
||
|
||
if (mmr != MMSYSERR_NOERROR)
|
||
{
|
||
DEBUGMSG (ZONE_DP, ("%s: acmStreamConvert failed, mmr=%ld\r\n", _fx_, (ULONG) mmr));
|
||
hr = DPR_CONVERSION_FAILED;
|
||
}
|
||
else
|
||
{
|
||
m_StrmConvHdr.dwDstUser = BUFFER_RECEIVED; // buffer is ready to play
|
||
// if receive side silence detection is turned on,
|
||
// check decoded buffer signal level
|
||
if (m_DPFlags & DP_FLAG_AUTO_SILENCE_DETECT)
|
||
{
|
||
if (m_AudioMonitor.SilenceDetect((WORD) GetSignalStrength()))
|
||
{
|
||
m_StrmConvHdr.dwDstUser = BUFFER_SILENT;
|
||
}
|
||
}
|
||
}
|
||
|
||
return hr;
|
||
// end
|
||
}
|
||
|
||
// insert the decoded buf at the appropriate location in the DirectSound buffer
|
||
HRESULT
|
||
RecvDSAudioStream::PlayBuf(DWORD timestamp, UINT seq, BOOL fMark)
|
||
{
|
||
UINT lenT = BYTESTOSAMPLES(m_StrmConvHdr.cbDstLengthUsed);
|
||
DWORD curPlayPosT, curWritePosT, curWriteLagT;
|
||
LPVOID p1, p2;
|
||
DWORD cb1, cb2;
|
||
HRESULT hr;
|
||
DWORD dwDSStatus = 0;
|
||
|
||
/*
|
||
All of the following are expressed in samples:
|
||
m_NextTimeT is timestamp of next expected packet. Usually timestamp equals m_NextT
|
||
m_BufSizeT is the total buffer size in samples.
|
||
m_NextPosT is the write position corresponding to m_NextT.
|
||
m_PlayPosT is the current play position
|
||
m_DelayT is the ideal playback delay
|
||
*/
|
||
|
||
LOG((LOGMSG_DSTIME, GetTickCount()));
|
||
LOG((LOGMSG_DSENTRY, timestamp, seq, fMark));
|
||
|
||
m_pDSBuf->GetCurrentPosition(&curPlayPosT,&curWritePosT);
|
||
curPlayPosT = BYTESTOSAMPLES(curPlayPosT);
|
||
curWritePosT = BYTESTOSAMPLES(curWritePosT);
|
||
m_pDSBuf->GetStatus(&dwDSStatus);
|
||
|
||
if (!m_fEmpty)
|
||
{
|
||
// wasn't empty last time we checked but is it empty now?
|
||
if (QMOD(curPlayPosT-m_PlayPosT, m_BufSizeT) > QMOD(m_NextPosT-m_PlayPosT, m_BufSizeT))
|
||
{
|
||
// play cursor has advanced beyond the last written byte
|
||
m_fEmpty = TRUE;
|
||
LOG((LOGMSG_DSEMPTY, curPlayPosT, m_PlayPosT, m_NextPosT));
|
||
}
|
||
// write silence into the part of the buffer that just played
|
||
hr = m_pDSBuf->Lock(SAMPLESTOBYTES(m_PlayPosT),SAMPLESTOBYTES(QMOD(curPlayPosT-m_PlayPosT, m_BufSizeT)), &p1, &cb1, &p2, &cb2, 0);
|
||
if (hr == S_OK)
|
||
{
|
||
ZeroMemory(p1,cb1);
|
||
if (cb2)
|
||
ZeroMemory(p2,cb2);
|
||
m_pDSBuf->Unlock(p1,cb1,p2,cb2);
|
||
}
|
||
}
|
||
hr = S_OK;
|
||
|
||
// calculate minimum write-behind margin.
|
||
// This is low for native sound drivers and high for emulated drivers, so , assuming it's accurate
|
||
// there's no need to distinguish between emulated and native drivers.
|
||
curWriteLagT = QMOD(curWritePosT-curPlayPosT, m_BufSizeT);
|
||
|
||
|
||
if (m_fEmpty)
|
||
{
|
||
// the DS buffer only has silence in it. In this state, m_NextPosT and m_NextTimeT are irrelevant.
|
||
// We get to put the new buffer wherever we choose, so we put it m_DelayT after the current write position.
|
||
curWritePosT = QMOD(curWritePosT+m_DelayT, m_BufSizeT);
|
||
|
||
}
|
||
else
|
||
{
|
||
|
||
if (TS_EARLIER(timestamp, m_NextTimeT))
|
||
hr = DPR_OUT_OF_SEQUENCE; // act dumb and discard misordered packets
|
||
else
|
||
{
|
||
UINT curDelayT = QMOD(m_NextPosT - curPlayPosT, m_BufSizeT);
|
||
if (fMark)
|
||
{
|
||
// we have some leeway in choosing the insertion point, because this is the start of a talkspurt
|
||
if (curDelayT > m_DelayT + curWriteLagT)
|
||
{
|
||
// put it right after the last sample
|
||
curWritePosT = m_NextPosT;
|
||
}
|
||
else
|
||
{
|
||
// put it m_DelayT after the current write position
|
||
curWritePosT = QMOD(curWritePosT+m_DelayT, m_BufSizeT);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// bytes in
|
||
if ((timestamp-m_NextTimeT + curDelayT) < m_BufSizeT)
|
||
{
|
||
curWritePosT = QMOD(m_NextPosT +timestamp-m_NextTimeT, m_BufSizeT);
|
||
}
|
||
else
|
||
{
|
||
// overflow!! Could either dump whats in buffer or dump the packet
|
||
// dumping the packet is easier for now
|
||
hr = DPR_OUT_OF_SEQUENCE;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if ((dwDSStatus & DSBSTATUS_PLAYING) && (seq != INVALID_RTP_SEQ_NUMBER))
|
||
UpdateVariableDelay(timestamp,curPlayPosT );
|
||
// When receive silence detection is enabled:
|
||
// dont play the packet if we have received at least a quarter second of silent packets.
|
||
// This will enable switch to talk (in half-duplex mode).
|
||
if (m_StrmConvHdr.dwDstUser == BUFFER_SILENT)
|
||
m_SilenceDurationT += lenT;
|
||
else
|
||
m_SilenceDurationT = 0;
|
||
|
||
if (hr == S_OK && m_SilenceDurationT < m_fDevRecv.nSamplesPerSec/4)
|
||
{
|
||
LOG((LOGMSG_DSPLAY,curPlayPosT, curWritePosT, lenT));
|
||
// check if we have space for the whole packet
|
||
if (QMOD(curWritePosT-curPlayPosT, m_BufSizeT) > m_BufSizeT - lenT)
|
||
{
|
||
// no
|
||
curPlayPosT = QMOD(curWritePosT + lenT + 1000, m_BufSizeT);
|
||
hr = m_pDSBuf->SetCurrentPosition(SAMPLESTOBYTES(curPlayPosT));
|
||
LOG((LOGMSG_DSMOVPOS,curPlayPosT, hr));
|
||
}
|
||
|
||
hr = m_pDSBuf->Lock(SAMPLESTOBYTES(curWritePosT),m_StrmConvHdr.cbDstLengthUsed, &p1, &cb1, &p2, &cb2, 0);
|
||
if (hr == S_OK)
|
||
{
|
||
CopyMemory(p1, m_StrmConvHdr.pbDst, cb1);
|
||
if (cb2)
|
||
CopyMemory(p2, m_StrmConvHdr.pbDst+cb1, cb2);
|
||
m_pDSBuf->Unlock(p1,cb1,p2,cb2);
|
||
|
||
m_fEmpty = FALSE;
|
||
}
|
||
else
|
||
{
|
||
DEBUGMSG(ZONE_DP,("DirectSoundBuffer->Lock failed with %x\n",hr));
|
||
}
|
||
m_StrmConvHdr.dwDstUser = 0; // to indicate that the decode buffer is empty again
|
||
m_NextTimeT = timestamp + lenT;
|
||
m_NextPosT = QMOD(curWritePosT+lenT, m_BufSizeT);
|
||
// now calculate total queued length
|
||
lenT = QMOD(m_NextPosT- curPlayPosT, m_BufSizeT);
|
||
// Reset the timer to trigger shortly after the last valid sample has played
|
||
// The timer serves two purposes:
|
||
// - ensure that the DS buffer is silenced before it wraps around
|
||
// - allow the DS object to be released in the half-duplex case, once the remote stops sending
|
||
// convert to millisecs
|
||
// Need to make sure the timeout happens before the DS buffer wrapsaround.
|
||
|
||
if (lenT > m_BufSizeT/2)
|
||
lenT = m_BufSizeT/2;
|
||
lenT = lenT * 1000/ m_fDevRecv.nSamplesPerSec;
|
||
m_pDP->m_RecvTimer.CancelTimeout(&m_TimeoutObj);
|
||
m_TimeoutObj.SetDueTime(GetTickCount()+lenT+100);
|
||
m_pDP->m_RecvTimer.SetTimeout(&m_TimeoutObj);
|
||
}
|
||
m_PlayPosT = curPlayPosT;
|
||
return hr;
|
||
|
||
}
|
||
// This routine is called on every packet to perform the adaptive delay calculation
|
||
// Remote time is measured by the RTP timestamp and local time is measured by the DirectSound
|
||
// play pointer.
|
||
// The general idea is to average how much a packet is later than its 'expected' arrival time,
|
||
// assuming the packet with the shortest trip delay is dead on time.
|
||
//
|
||
void
|
||
RecvDSAudioStream::UpdateVariableDelay(DWORD sendT, DWORD curPlayPosT)
|
||
{
|
||
#define PLAYOUT_DELAY_FACTOR 2
|
||
LONG deltaA, deltaS;
|
||
DWORD delay;
|
||
// update arrival time based on how much the DS play pointer has advanced
|
||
// since the last packet
|
||
m_ArrT += QMOD(curPlayPosT-m_PlayPosT, m_BufSizeT);
|
||
// m_ArrivalT0 and m_SendT0 are the arrival and send timestamps of the packet
|
||
// with the shortest trip delay. We could have just stored (m_ArrivalT0 - m_SendT0)
|
||
// but since the local and remote clocks are completely unsynchronized, there would
|
||
// be signed/unsigned complications.
|
||
deltaS = sendT - m_SendT0;
|
||
deltaA = m_ArrT - m_ArrivalT0;
|
||
if (deltaA < deltaS // this packet took less time
|
||
|| deltaA > (int)m_fDevRecv.nSamplesPerSec*8 // reset every 8 secs
|
||
|| deltaS < -(int)m_fDevRecv.nSamplesPerSec // or after big timestamp jumps
|
||
)
|
||
{
|
||
delay = 0;
|
||
// delay = deltaS - deltaA
|
||
// replace shortest trip delay times
|
||
m_SendT0 = sendT;
|
||
m_ArrivalT0 = m_ArrT;
|
||
} else {
|
||
// variable delay is how much longer this packet took
|
||
delay = deltaA - deltaS;
|
||
}
|
||
// now update average variable delay according to
|
||
// m_AvgVarDelay = m_AvgVarDelay + (delay - m_AvgVarDelay)*1/16;
|
||
// however we are storing the scaled average, with a scaling
|
||
// factor of 16. So the calculation becomes
|
||
m_ScaledAvgVarDelay = m_ScaledAvgVarDelay + (delay - m_ScaledAvgVarDelay/16);
|
||
// now calculate actual buffering delay we will use
|
||
// MinDelay adds some slack (may be necessary for some drivers)
|
||
m_DelayT = m_MinDelayT + PLAYOUT_DELAY_FACTOR * m_ScaledAvgVarDelay/16;
|
||
if (m_DelayT > m_MaxDelayT) m_DelayT = m_MaxDelayT;
|
||
|
||
LOG((LOGMSG_JITTER,delay, m_ScaledAvgVarDelay/16, m_DelayT));
|
||
|
||
|
||
UPDATE_COUNTER(g_pctrAudioJBDelay, (m_DelayT * 1000)/m_fDevRecv.nSamplesPerSec);
|
||
|
||
}
|
||
|
||
void
|
||
RecvDSAudioStream::RecvTimeout()
|
||
{
|
||
DWORD curPlayPosT, curWritePosT;
|
||
LPVOID p1, p2;
|
||
DWORD cb1, cb2;
|
||
UINT lenT;
|
||
HRESULT hr;
|
||
|
||
if (m_pDSBuf == NULL)
|
||
{
|
||
WARNING_OUT(("RecvDSAudioStream::RecvTimeout - DirectSoundBuffer is not valid\r\n"));
|
||
return;
|
||
}
|
||
|
||
|
||
m_pDSBuf->GetCurrentPosition(&curPlayPosT,&curWritePosT);
|
||
curPlayPosT = BYTESTOSAMPLES(curPlayPosT);
|
||
curWritePosT = BYTESTOSAMPLES(curWritePosT);
|
||
|
||
// this part is cut and pasted from PlayBuf
|
||
if (!m_fEmpty) {
|
||
// wasn't empty last time we checked but is it empty now?
|
||
if (QMOD(curPlayPosT-m_PlayPosT, m_BufSizeT) > QMOD(m_NextPosT-m_PlayPosT, m_BufSizeT)) {
|
||
// play cursor has advanced beyond the last written byte
|
||
m_fEmpty = TRUE;
|
||
}
|
||
// write silence into the part of the buffer that just played
|
||
hr = m_pDSBuf->Lock(SAMPLESTOBYTES(m_PlayPosT),SAMPLESTOBYTES(QMOD(curPlayPosT-m_PlayPosT, m_BufSizeT)), &p1, &cb1, &p2, &cb2, 0);
|
||
if (hr == S_OK) {
|
||
ZeroMemory(p1,cb1);
|
||
if (cb2)
|
||
ZeroMemory(p2,cb2);
|
||
m_pDSBuf->Unlock(p1,cb1,p2,cb2);
|
||
}
|
||
}
|
||
LOG((LOGMSG_DSTIMEOUT, curPlayPosT, m_NextPosT, GetTickCount()));
|
||
|
||
m_PlayPosT = curPlayPosT;
|
||
if (!m_fEmpty) {
|
||
// The buffer isnt quite empty yet!
|
||
// Reschedule??
|
||
DEBUGMSG(ZONE_DP,("DSBuffer not empty after timeout\n"));
|
||
lenT = QMOD(m_NextPosT- curPlayPosT, m_BufSizeT);
|
||
// Reset the timer to trigger shortly after the last valid sample has played
|
||
// Need to make sure the timeout happens before the DS buffer wrapsaround.
|
||
if (lenT > m_BufSizeT/2)
|
||
lenT = m_BufSizeT/2;
|
||
// convert to millisecs
|
||
lenT = lenT * 1000/ m_fDevRecv.nSamplesPerSec;
|
||
m_TimeoutObj.SetDueTime(GetTickCount()+lenT+100);
|
||
m_pDP->m_RecvTimer.SetTimeout(&m_TimeoutObj);
|
||
}
|
||
else if (m_DPFlags & DP_FLAG_HALF_DUPLEX)
|
||
{
|
||
// need to release the DSBuffer and DSObject
|
||
ReleaseDSBuffer();
|
||
}
|
||
}
|
||
|
||
HRESULT RecvDSAudioStream::RTPCallback(WSABUF *pWsaBuf, DWORD timestamp, UINT seq, UINT fMark)
|
||
{
|
||
HRESULT hr;
|
||
|
||
if (m_ThreadFlags & DPTFLAG_PAUSE_RECV)
|
||
{
|
||
return E_FAIL;
|
||
}
|
||
|
||
// update number of bits received
|
||
UPDATE_COUNTER(g_pctrAudioReceiveBytes,(pWsaBuf->len + IP_HEADER_SIZE + UDP_HEADER_SIZE)*8);
|
||
|
||
hr = Decode((BYTE *)pWsaBuf->buf + sizeof(RTP_HDR), pWsaBuf->len - sizeof(RTP_HDR));
|
||
if (hr == S_OK )
|
||
{
|
||
// Have we initialized DirectSound?
|
||
// Yes, unless its half-duplex
|
||
if (!m_pDSBuf)
|
||
{
|
||
hr = CreateDSBuffer();
|
||
}
|
||
if (hr == S_OK)
|
||
{
|
||
PlayBuf(timestamp, seq, fMark);
|
||
}
|
||
}
|
||
m_pIRTPRecv->FreePacket(pWsaBuf);
|
||
return S_OK;
|
||
}
|
||
|
||
// this method called from the UI thread only
|
||
HRESULT RecvDSAudioStream::DTMFBeep()
|
||
{
|
||
if ( (!(m_DPFlags & DPFLAG_STARTED_RECV)) ||
|
||
(m_ThreadFlags & DPTFLAG_PAUSE_RECV) )
|
||
{
|
||
return E_FAIL;
|
||
}
|
||
|
||
m_pDP->RecvThreadMessage(MSG_PLAY_SOUND, this);
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
HRESULT RecvDSAudioStream::OnDTMFBeep()
|
||
{
|
||
int nBeeps;
|
||
DWORD dwBufSize = m_StrmConvHdr.cbDstLength;
|
||
HRESULT hr=S_OK;
|
||
int nIndex;
|
||
|
||
if ( (!(m_DPFlags & DPFLAG_STARTED_RECV)) ||
|
||
(m_ThreadFlags & DPTFLAG_PAUSE_RECV) )
|
||
{
|
||
return E_FAIL;
|
||
}
|
||
|
||
if (dwBufSize == 0)
|
||
{
|
||
return E_FAIL;
|
||
}
|
||
|
||
|
||
nBeeps = DTMF_FEEDBACK_BEEP_MS / ((dwBufSize * 1000) / m_fDevRecv.nAvgBytesPerSec);
|
||
|
||
if (nBeeps == 0)
|
||
{
|
||
nBeeps = 1;
|
||
}
|
||
|
||
MakeDTMFBeep(&m_fDevRecv, m_StrmConvHdr.pbDst , m_StrmConvHdr.cbDstLength);
|
||
|
||
if (!m_pDSBuf)
|
||
{
|
||
hr = CreateDSBuffer();
|
||
if (FAILED(hr))
|
||
{
|
||
return hr;
|
||
}
|
||
}
|
||
|
||
|
||
m_StrmConvHdr.dwDstUser = BUFFER_RECEIVED;
|
||
PlayBuf(m_NextTimeT , INVALID_RTP_SEQ_NUMBER, true);
|
||
nBeeps--;
|
||
|
||
for (nIndex = 0; nIndex < nBeeps; nIndex++)
|
||
{
|
||
m_StrmConvHdr.dwDstUser = BUFFER_RECEIVED;
|
||
PlayBuf(m_NextTimeT, INVALID_RTP_SEQ_NUMBER, false);
|
||
}
|
||
|
||
return S_OK;
|
||
|
||
}
|
||
|
||
|