You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
994 lines
27 KiB
994 lines
27 KiB
/*==========================================================================
|
|
*
|
|
* Copyright (C) 1999 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* File: dvsndt.cpp
|
|
* Content: Implementation of CSoundTarget class
|
|
*
|
|
* History:
|
|
* Date By Reason
|
|
* ==== == ======
|
|
* 09/02/99 rodtoll Created
|
|
* 09/08/99 rodtoll Updated to handle lockup of playback buffer
|
|
* rodtoll Added handling for restarting playback buffer or
|
|
* handling slowdown/speedup of buffer playback
|
|
* because of high cpu loads.
|
|
* rodtoll Added write-ahead of silence to the buffers to that
|
|
* in high CPU conditions silence will be played instead
|
|
* of old voice.
|
|
* 09/14/99 rodtoll Added new WriteAheadSilence which writes silence ahead
|
|
* of the current write location to prevent high CPU from
|
|
* playing old data.
|
|
* 09/20/99 rodtoll Added checks for memory allocation failures
|
|
* rodtoll Added handlers for buffer loss
|
|
* 10/05/99 rodtoll Added additional comments
|
|
* 10/25/99 rodtoll Fix: Bug #114223 - Debug messages being printed at error level when inappropriate
|
|
* 11/02/99 pnewson Fix: Bug #116365 - using wrong DSBUFFERDESC
|
|
* 11/12/99 rodtoll Updated to use new abstractions for playback (allows use
|
|
* of waveOut with this class).
|
|
* 11/13/99 rodtoll Re-activated code which pushes write pointer ahead if
|
|
* buffer pointer passes us.
|
|
* 01/24/2000 rodtoll Fix: Bug #129427 - Destroying transport before calling Delete3DSound
|
|
* 01/27/2000 rodtoll Bug #129934 - Update SoundTargets to take DSBUFFERDESC
|
|
* 02/17/2000 rodtoll Bug #133691 - Choppy audio - queue was not adapting
|
|
* Added instrumentation
|
|
* 04/14/2000 rodtoll Bug #32215 - Voice Conference Lost after resume from hibernation
|
|
* Updated code to use new restore handling in dsound layer
|
|
* 05/17/2000 rodtoll Bug #35110 Simultaneous playback of 2 voices results in distorted playback
|
|
* 06/21/2000 rodtoll Fix: Bug #35767 - Must implement ability for dsound effects on voice buffers
|
|
* Added new constructor/init that takes pre-built buffers
|
|
* 07/09/2000 rodtoll Added signature bytes
|
|
* 07/28/2000 rodtoll Bug #40665 - DirectSound reports 1 buffer leaked
|
|
* 11/16/2000 rodtoll Bug #47783 - DPVOICE: Improve debugging of failures caused by DirectSound errors.
|
|
* 04/02/2001 simonpow Bug #354859 Fixes for PREfast (initialising local variables in RestoreLostBuffer)
|
|
* 04/21/2001 rodtoll MANBUG #50058 DPVOICE: VoicePosition: No sound for couple of seconds when position bars are moved
|
|
* - Added initialization for uninitialized variables
|
|
* - Removed ifdef'ed out code.
|
|
*
|
|
***************************************************************************/
|
|
|
|
#include "dxvoicepch.h"
|
|
|
|
|
|
#define SOUNDTARGET_WRITEAHEAD 2
|
|
|
|
// Max # of restarts to attempt on a buffer
|
|
#define SOUNDTARGET_MAX_RESTARTS 10
|
|
|
|
// Max # of frames of silence which are written ahead of the latest frame
|
|
// of audio
|
|
#define SOUNDTARGET_MAX_WRITEAHEAD 3
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::CSoundTarget"
|
|
//
|
|
// Constructor
|
|
//
|
|
// This constructor is used when a DIRECTSOUND buffer needs to be created. If there is already
|
|
// a DIRECTSOUNDBUFFER you wish to attach the sound target object to, use the other constructor
|
|
// type.
|
|
//
|
|
CSoundTarget::CSoundTarget(
|
|
DVID dvidTarget, CAudioPlaybackDevice *lpPlaybackDevice,
|
|
LPDSBUFFERDESC lpdsBufferDesc, DWORD dwPriority,
|
|
DWORD dwFlags, DWORD dwFrameSize
|
|
): m_lpds3dBuffer(NULL),
|
|
m_lpAudioPlaybackBuffer(NULL),
|
|
m_lpMixBuffer(NULL),
|
|
m_dwSignature(VSIG_SOUNDTARGET),
|
|
m_lRefCount(1)
|
|
{
|
|
CAudioPlaybackBuffer *lpdsBuffer;
|
|
LPVOID lpvBuffer1, lpvBuffer2;
|
|
DWORD dwBufferSize1, dwBufferSize2;
|
|
|
|
Stats_Init();
|
|
|
|
m_hrInitResult = lpPlaybackDevice->CreateBuffer( lpdsBufferDesc, dwFrameSize, &lpdsBuffer );
|
|
|
|
if( FAILED( m_hrInitResult ) )
|
|
{
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Could not create the sound buffer hr=0x%x", m_hrInitResult );
|
|
return;
|
|
}
|
|
|
|
m_hrInitResult = lpdsBuffer->Lock( 0, 0, &lpvBuffer1, &dwBufferSize1, &lpvBuffer2, &dwBufferSize2, DSBLOCK_ENTIREBUFFER );
|
|
|
|
if( FAILED( m_hrInitResult ) )
|
|
{
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Could not lock the sound buffer hr=0x%x", m_hrInitResult );
|
|
m_hrInitResult = DVERR_LOCKEDBUFFER;
|
|
return;
|
|
}
|
|
|
|
if( lpdsBufferDesc->lpwfxFormat->wBitsPerSample == 8 )
|
|
{
|
|
memset( lpvBuffer1, 0x80, dwBufferSize1 );
|
|
}
|
|
else
|
|
{
|
|
memset( lpvBuffer1, 0x00, dwBufferSize1 );
|
|
}
|
|
|
|
m_hrInitResult = lpdsBuffer->UnLock( lpvBuffer1, dwBufferSize1, lpvBuffer2, dwBufferSize2 );
|
|
|
|
if( FAILED( m_hrInitResult ) )
|
|
{
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Could not unlock the sound buffer hr=0x%x", m_hrInitResult );
|
|
return;
|
|
}
|
|
|
|
// Required always
|
|
dwFlags |= DSBPLAY_LOOPING;
|
|
|
|
m_hrInitResult = lpdsBuffer->Play( dwPriority, dwFlags );
|
|
|
|
if( FAILED( m_hrInitResult ) )
|
|
{
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Could not play the sound buffer hr=0x%x", m_hrInitResult );
|
|
return;
|
|
}
|
|
|
|
m_hrInitResult = Initialize( dvidTarget, lpdsBuffer, (lpdsBufferDesc->lpwfxFormat->wBitsPerSample==8), dwPriority, dwFlags, dwFrameSize );
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::RestoreLostBuffer"
|
|
//
|
|
// RestoreLostBuffer
|
|
//
|
|
// Handles restoration of lost directsound buffers.
|
|
//
|
|
HRESULT CSoundTarget::RestoreLostBuffer()
|
|
{
|
|
HRESULT hr = DSERR_BUFFERLOST;
|
|
|
|
DPFX(DPFPREP, 0, "Restoring lost buffer" );
|
|
|
|
while( hr == DSERR_BUFFERLOST )
|
|
{
|
|
hr = m_lpAudioPlaybackBuffer->Restore();
|
|
|
|
DPFX(DPFPREP, 0, "Buffer result for restore was 0x%x", hr );
|
|
|
|
if( hr == DS_OK )
|
|
{
|
|
hr = m_lpAudioPlaybackBuffer->GetCurrentPosition( &m_dwWritePos );
|
|
DPFX(DPFPREP, 0, "GetCurrentPos returned 0x%x", hr );
|
|
|
|
if( hr != DSERR_BUFFERLOST && FAILED( hr ) )
|
|
{
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Lost buffer while getting pos, failed to get pos hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
}
|
|
else if( hr != DSERR_BUFFERLOST )
|
|
{
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Error restoring buffer hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
// STATBLOCK: Begin
|
|
m_statPlay.m_dwNumBL++;
|
|
// STATBLOCK: End
|
|
|
|
m_dwNextWritePos = m_dwWritePos + (m_dwFrameSize*SOUNDTARGET_WRITEAHEAD);
|
|
m_dwNextWritePos %= m_dwBufferSize;
|
|
|
|
m_dwLastWritePos = m_dwWritePos;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::CSoundTarget"
|
|
//
|
|
// Constructor
|
|
//
|
|
// This constructor is used when you wish to attach a soundtarget to an existing
|
|
// DirectSond buffer.
|
|
//
|
|
CSoundTarget::CSoundTarget(
|
|
DVID dvidTarget, CAudioPlaybackDevice *lpads,
|
|
CAudioPlaybackBuffer *lpdsBuffer, LPDSBUFFERDESC lpdsBufferDesc,
|
|
DWORD dwPriority, DWORD dwFlags, DWORD dwFrameSize
|
|
): m_lpds3dBuffer(NULL),
|
|
m_lpAudioPlaybackBuffer(NULL),
|
|
m_lpMixBuffer(NULL),
|
|
m_dwSignature(VSIG_SOUNDTARGET),
|
|
m_lRefCount(1)
|
|
{
|
|
m_hrInitResult = Initialize( dvidTarget, lpdsBuffer, (lpdsBufferDesc->lpwfxFormat->wBitsPerSample==8), dwPriority, dwFlags, dwFrameSize );
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::CSoundTarget"
|
|
CSoundTarget::CSoundTarget(
|
|
DVID dvidTarget,
|
|
CAudioPlaybackDevice *lpads,
|
|
LPDIRECTSOUNDBUFFER lpdsBuffer,
|
|
BOOL fEightBit,
|
|
DWORD dwPriority,
|
|
DWORD dwFlags,
|
|
DWORD dwFrameSize
|
|
): m_lpds3dBuffer(NULL),
|
|
m_lpAudioPlaybackBuffer(NULL),
|
|
m_lpMixBuffer(NULL),
|
|
m_dwSignature(VSIG_SOUNDTARGET),
|
|
m_lRefCount(1)
|
|
{
|
|
CDirectSoundPlaybackBuffer *pAudioBuffer = NULL;
|
|
|
|
// Create audio buffer to wrap buffer for call to initialize
|
|
pAudioBuffer = new CDirectSoundPlaybackBuffer( lpdsBuffer );
|
|
|
|
if( pAudioBuffer == NULL )
|
|
{
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Error allocating memory" );
|
|
m_hrInitResult = DVERR_OUTOFMEMORY;
|
|
return;
|
|
}
|
|
|
|
// Required always
|
|
dwFlags |= DSBPLAY_LOOPING;
|
|
|
|
m_hrInitResult = pAudioBuffer->Play( dwPriority, dwFlags );
|
|
|
|
if( FAILED( m_hrInitResult ) )
|
|
{
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed playing new buffer hr=0x%x", m_hrInitResult );
|
|
return;
|
|
}
|
|
|
|
m_hrInitResult = Initialize( dvidTarget, pAudioBuffer, fEightBit, dwPriority, dwFlags, dwFrameSize );
|
|
}
|
|
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::~CSoundTarget"
|
|
//
|
|
// Destructor
|
|
//
|
|
// Destroys the 3d and buffer pointers and frees memory.
|
|
//
|
|
CSoundTarget::~CSoundTarget()
|
|
{
|
|
Stats_End();
|
|
|
|
if( m_lpds3dBuffer != NULL )
|
|
{
|
|
m_lpds3dBuffer->Release();
|
|
m_lpds3dBuffer = NULL;
|
|
}
|
|
|
|
if( m_lpAudioPlaybackBuffer != NULL )
|
|
{
|
|
m_lpAudioPlaybackBuffer->Stop();
|
|
delete m_lpAudioPlaybackBuffer;
|
|
m_lpAudioPlaybackBuffer = NULL;
|
|
}
|
|
|
|
if( m_lpMixBuffer != NULL )
|
|
{
|
|
delete [] m_lpMixBuffer;
|
|
m_lpMixBuffer = NULL;
|
|
}
|
|
|
|
if( SUCCEEDED( m_hrInitResult ) )
|
|
{
|
|
DNDeleteCriticalSection( &m_csGuard );
|
|
}
|
|
|
|
m_dwSignature = VSIG_SOUNDTARGET_FREE;
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::AdjustWritePtr"
|
|
//
|
|
// AdjustWritePtr
|
|
//
|
|
// This function ensures that the directsoundbuffer is acting as it should. It handles
|
|
// checking the write pointer and determining if some form of error or problem has
|
|
// occured and taking the appropriate corrective action.
|
|
//
|
|
// E.g. the buffer hasn't moved since the last frame, the buffer hasn't moved enough,
|
|
// the buffer has skipped ahead etc.
|
|
//
|
|
// This function should be called once per mixing pass.
|
|
//
|
|
// Call before writing the frame
|
|
//
|
|
HRESULT CSoundTarget::AdjustWritePtr()
|
|
{
|
|
HRESULT hr;
|
|
LONG lDifference, lHalfSize;
|
|
DWORD dwCurrentTick;
|
|
|
|
hr = m_lpAudioPlaybackBuffer->GetCurrentPosition( &m_dwWritePos );
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "GetCurrentPosition Failed hr=0x%x", hr );
|
|
DSASSERT( FALSE );
|
|
return hr;
|
|
}
|
|
|
|
// STATSBLOCK: Begin
|
|
m_statPlay.m_dwNumRuns++;
|
|
// STATSBLOCK: End
|
|
|
|
DWORD dwTmpAdvance, dwTmpLead;
|
|
|
|
dwCurrentTick = GetTickCount();
|
|
|
|
if( m_dwLastWritePos > m_dwWritePos )
|
|
{
|
|
dwTmpAdvance = (m_dwBufferSize - m_dwLastWritePos) + m_dwWritePos;
|
|
}
|
|
else
|
|
{
|
|
dwTmpAdvance = m_dwWritePos - m_dwLastWritePos;
|
|
}
|
|
|
|
if( m_dwNextWritePos < m_dwWritePos )
|
|
{
|
|
dwTmpLead = (m_dwBufferSize-m_dwWritePos) + m_dwNextWritePos;
|
|
}
|
|
else
|
|
{
|
|
dwTmpLead = m_dwNextWritePos - m_dwWritePos;
|
|
}
|
|
|
|
DPFX(DPFPREP, PWI_DEBUGOUTPUT_LEVEL, "PWI, [0x%x], %d, %d, %d, %d, %d, %d", m_dvidTarget, m_dwWritePos, dwTmpAdvance,
|
|
dwCurrentTick - m_dwLastWriteTime, m_dwNextWritePos, dwTmpLead, m_dwFrameSize );
|
|
|
|
// STATSBLOCK: Begin
|
|
|
|
DWORD dwTmpDiff = dwCurrentTick - m_dwLastWriteTime;
|
|
|
|
if( dwTmpDiff > m_statPlay.m_dwPMMSMax )
|
|
{
|
|
m_statPlay.m_dwPMMSMax = dwTmpDiff;
|
|
}
|
|
|
|
if( dwTmpDiff < m_statPlay.m_dwPMMSMin )
|
|
{
|
|
m_statPlay.m_dwPMMSMin = dwTmpDiff;
|
|
}
|
|
|
|
m_statPlay.m_dwPMMSTotal += dwTmpDiff;
|
|
|
|
if( dwTmpAdvance > m_statPlay.m_dwPMBMax )
|
|
{
|
|
m_statPlay.m_dwPMBMax = dwTmpAdvance;
|
|
}
|
|
|
|
if( dwTmpAdvance < m_statPlay.m_dwPMBMin )
|
|
{
|
|
m_statPlay.m_dwPMBMin = dwTmpAdvance;
|
|
}
|
|
|
|
m_statPlay.m_dwPMBTotal += dwTmpAdvance;
|
|
|
|
if( dwTmpLead > m_statPlay.m_dwPLMax )
|
|
{
|
|
m_statPlay.m_dwPLMax = dwTmpLead;
|
|
}
|
|
|
|
if( dwTmpLead < m_statPlay.m_dwPLMin )
|
|
{
|
|
m_statPlay.m_dwPLMin = dwTmpLead;
|
|
}
|
|
|
|
m_statPlay.m_dwPLTotal += dwTmpLead;
|
|
// STATSBLOCK: End
|
|
|
|
lHalfSize = m_dwBufferSize / 2;
|
|
lDifference = m_dwNextWritePos - m_dwWritePos;
|
|
|
|
// If the write position is somehow ahead of position AND
|
|
//
|
|
if( lDifference < 0 &&
|
|
lDifference > (-1*lHalfSize) )
|
|
{
|
|
m_dwNextWritePos = m_dwWritePos;
|
|
m_dwNextWritePos += (m_dwFrameSize * SOUNDTARGET_WRITEAHEAD);
|
|
m_dwNextWritePos %= m_dwBufferSize;
|
|
|
|
DPFX(DPFPREP, PWI_DEBUGOUTPUT_LEVEL, "PWI, [0x%x], Punt --> %d", m_dvidTarget, m_dwNextWritePos );
|
|
|
|
// STATSBLOCK: Begin
|
|
m_statPlay.m_dwPPunts++;
|
|
|
|
DPFX(DPFPREP, DVF_GLITCH_DEBUG_LEVEL, "GLITCH: [0x%x] Playback: Write pointer has fallen behind buffer pointer. Compensating", m_dvidTarget );
|
|
|
|
m_statPlay.m_dwGlitches++;
|
|
|
|
// STATSBLOCK: End
|
|
}
|
|
|
|
|
|
m_dwLastWritePos = m_dwWritePos;
|
|
m_dwLastWriteTime = dwCurrentTick;
|
|
|
|
if( m_dwNextWritePos < m_dwWritePos &&
|
|
(m_dwNextWritePos + m_dwFrameSize) > m_dwWritePos )
|
|
{
|
|
DPFX(DPFPREP, PWI_DEBUGOUTPUT_LEVEL, "PWI, [0x%x], Ignore - Crossing", m_dvidTarget );
|
|
m_fIgnoreFrame = TRUE;
|
|
// STATSBLOCK: Begin
|
|
m_statPlay.m_dwPIgnore++;
|
|
|
|
DPFX(DPFPREP, DVF_GLITCH_DEBUG_LEVEL, "GLITCH: [0x%x] Playback: Current frame will cross buffer pointer. Ignoring", m_dvidTarget );
|
|
DPFX(DPFPREP, DVF_GLITCH_DEBUG_LEVEL, "GLITCH: [0x%x] Playback: May be catching up with buiffer pointer", m_dvidTarget );
|
|
|
|
m_statPlay.m_dwGlitches++;
|
|
// STATSBLOCK: End
|
|
}
|
|
else
|
|
{
|
|
m_fIgnoreFrame = FALSE;
|
|
}
|
|
|
|
return DV_OK;
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::WriteAheadSilence"
|
|
//
|
|
// WriteAheadSilence
|
|
//
|
|
// This function is responsible for writing frames of silence ahead of the latest frame
|
|
// placed in the buffer. This way if because of high CPU writer thread donesn't get woken
|
|
// up silence will be played instead of old speech.
|
|
//
|
|
// Called AFTER latest frame of data has been written.
|
|
//
|
|
HRESULT CSoundTarget::WriteAheadSilence()
|
|
{
|
|
HRESULT hr;
|
|
DWORD dwBufferSize1, dwBufferSize2;
|
|
LPVOID lpvBuffer1, lpvBuffer2;
|
|
|
|
if( m_dwNextWritePos < m_dwWritePos &&
|
|
(m_dwNextWritePos + (m_dwFrameSize*SOUNDTARGET_MAX_WRITEAHEAD)) > m_dwWritePos )
|
|
{
|
|
DPFX(DPFPREP, PWI_DEBUGOUTPUT_LEVEL, "PWI, [0x%x], Ignore2 - Crossing", m_dvidTarget );
|
|
|
|
// STATSBLOCK: Begin
|
|
m_statPlay.m_dwSIgnore++;
|
|
|
|
DPFX(DPFPREP, DVF_GLITCH_DEBUG_LEVEL, "GLITCH: Playback: Silence will cross buffer pointer. Ignoring" );
|
|
DPFX(DPFPREP, DVF_GLITCH_DEBUG_LEVEL, "GLITCH: Playback: May be catching up with buiffer pointer" );
|
|
|
|
// STATSBLOCK: End
|
|
return DV_OK;
|
|
}
|
|
|
|
hr = m_lpAudioPlaybackBuffer->Lock( m_dwNextWritePos, m_dwFrameSize*SOUNDTARGET_MAX_WRITEAHEAD, &lpvBuffer1, &dwBufferSize1, &lpvBuffer2, &dwBufferSize2, 0 );
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DSASSERT( FALSE );
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Lock() Failed hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
|
|
memset( lpvBuffer1, (m_fEightBit) ? 0x80 : 0x00, dwBufferSize1 );
|
|
memset( lpvBuffer2, (m_fEightBit) ? 0x80 : 0x00, dwBufferSize2 );
|
|
|
|
hr = m_lpAudioPlaybackBuffer->UnLock( lpvBuffer1, dwBufferSize1, lpvBuffer2, dwBufferSize2 );
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DSASSERT( FALSE );
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Unlock() Failed hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
|
|
return DV_OK;
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::MixInSingle"
|
|
//
|
|
// MixInSingle
|
|
//
|
|
// This function is an optimization.
|
|
//
|
|
// If there is only one frame to mix into this buffer, this function performs the
|
|
// MixIn and Commit all in one step. You still must call Commit before the next
|
|
// frame hwoever.
|
|
//
|
|
HRESULT CSoundTarget::MixInSingle( LPBYTE lpbBuffer )
|
|
{
|
|
HRESULT hr;
|
|
|
|
DWORD dwBufferSize1, dwBufferSize2;
|
|
LPVOID lpvBuffer1, lpvBuffer2;
|
|
|
|
hr = AdjustWritePtr();
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DSASSERT( FALSE );
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "AdjustWritePtr Failed hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
|
|
if( !m_fIgnoreFrame )
|
|
{
|
|
hr = m_lpAudioPlaybackBuffer->Lock( m_dwNextWritePos, m_dwFrameSize, &lpvBuffer1, &dwBufferSize1, &lpvBuffer2, &dwBufferSize2, 0 );
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Lock() Failed hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
|
|
memcpy( lpvBuffer1, lpbBuffer, dwBufferSize1 );
|
|
|
|
if( dwBufferSize2 )
|
|
{
|
|
memcpy( lpvBuffer2, &lpbBuffer[dwBufferSize1], dwBufferSize2 );
|
|
}
|
|
|
|
hr = m_lpAudioPlaybackBuffer->UnLock( lpvBuffer1, dwBufferSize1, lpvBuffer2, dwBufferSize2 );
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DSASSERT( FALSE );
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "UnLock() Failed hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
m_dwNextWritePos += m_dwFrameSize;
|
|
m_dwNextWritePos %= m_dwBufferSize;
|
|
|
|
m_bCommited = TRUE;
|
|
m_fMixed = TRUE;
|
|
|
|
return DV_OK;
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::MixIn"
|
|
// Mix in a user's audio.
|
|
//
|
|
// Simply copies and promotes the audio samples into the buffer with LONG's
|
|
// in it.
|
|
//
|
|
HRESULT CSoundTarget::MixIn( const BYTE* lpbBuffer )
|
|
{
|
|
DWORD dwIndex;
|
|
|
|
if( !m_fMixed )
|
|
{
|
|
FillBufferWithSilence( m_lpMixBuffer, m_fEightBit, m_dwFrameSize );
|
|
m_fMixed = TRUE;
|
|
}
|
|
|
|
if( !m_fIgnoreFrame )
|
|
MixInBuffer( m_lpMixBuffer, lpbBuffer, m_fEightBit, m_dwFrameSize );
|
|
|
|
m_bCommited = FALSE;
|
|
m_fMixed = TRUE;
|
|
|
|
return DV_OK;
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::Commit"
|
|
// Commit
|
|
//
|
|
// If we didn't do a single direct mix, commit the mixed audio to the buffer
|
|
//
|
|
HRESULT CSoundTarget::Commit()
|
|
{
|
|
DWORD dwBufferSize1, dwBufferSize2;
|
|
LPVOID lpvBuffer1, lpvBuffer2;
|
|
DWORD dwIndex = 0;
|
|
HRESULT hr;
|
|
|
|
if( !m_fMixed )
|
|
{
|
|
FillBufferWithSilence( m_lpMixBuffer, m_fEightBit, m_dwFrameSize );
|
|
|
|
// STATSBLOCK: Begin
|
|
m_statPlay.m_dwNumSilentMixed++;
|
|
// STATSBLOCK: End
|
|
}
|
|
else
|
|
{
|
|
if( !m_fIgnoreFrame )
|
|
{
|
|
// STATSBLOCK: Begin
|
|
m_statPlay.m_dwNumMixed++;
|
|
// STATSBLOCK: End
|
|
}
|
|
}
|
|
|
|
if( !m_bCommited || !m_fMixed )
|
|
{
|
|
hr = AdjustWritePtr();
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DSASSERT( FALSE );
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "AdjustWritePtr() Failed hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
|
|
if( !m_fIgnoreFrame )
|
|
{
|
|
hr = m_lpAudioPlaybackBuffer->Lock( m_dwNextWritePos, m_dwFrameSize, &lpvBuffer1, &dwBufferSize1, &lpvBuffer2, &dwBufferSize2, 0 );
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DSASSERT( FALSE );
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Lock() Failed hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
|
|
// Mix first half
|
|
NormalizeBuffer( (BYTE *) lpvBuffer1, m_lpMixBuffer, m_fEightBit, dwBufferSize1 );
|
|
|
|
if( dwBufferSize2 > 0 )
|
|
{
|
|
if( m_fEightBit )
|
|
{
|
|
// Mix second half
|
|
NormalizeBuffer( (BYTE *) lpvBuffer2, &m_lpMixBuffer[dwBufferSize1], m_fEightBit, dwBufferSize2 );
|
|
}
|
|
else
|
|
{
|
|
// Mix second half
|
|
NormalizeBuffer( (BYTE *) lpvBuffer2, &m_lpMixBuffer[(dwBufferSize1 >> 1)], m_fEightBit, dwBufferSize2 );
|
|
}
|
|
}
|
|
|
|
hr = m_lpAudioPlaybackBuffer->UnLock( lpvBuffer1, dwBufferSize1, lpvBuffer2, dwBufferSize2 );
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DSASSERT( FALSE );
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "UnLock Failed hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
m_dwNextWritePos += m_dwFrameSize;
|
|
m_dwNextWritePos %= m_dwBufferSize;
|
|
|
|
m_bCommited = FALSE;
|
|
m_fMixed = FALSE;
|
|
|
|
return DV_OK;
|
|
}
|
|
|
|
hr = WriteAheadSilence();
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DSASSERT( FALSE );
|
|
DPFX(DPFPREP, 0, "WriteAhead Failed hr=0x%x", hr );
|
|
}
|
|
|
|
m_fMixed = FALSE;
|
|
m_bCommited = FALSE;
|
|
|
|
return DV_OK;
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::Initialize"
|
|
//
|
|
// Initialize
|
|
//
|
|
// NOTE: Takes a reference to the buffer
|
|
//
|
|
// Attaches a sound target to the specified sound buffer, initializes the object and creates
|
|
// the associated 3d buffer.
|
|
//
|
|
HRESULT CSoundTarget::Initialize( DVID dvidTarget, CAudioPlaybackBuffer *lpdsBuffer, BOOL fEightBit, DWORD dwPriority, DWORD dwFlags, DWORD dwFrameSize )
|
|
{
|
|
HRESULT hr = DV_OK;
|
|
PVOID pvBuffer1 = NULL, pvBuffer2 = NULL;
|
|
DWORD dwBufferSize1, dwBufferSize2;
|
|
|
|
// Determine the buffer size (in bytes)
|
|
hr = lpdsBuffer->Lock( 0, 0, &pvBuffer1, &dwBufferSize1, &pvBuffer2, &dwBufferSize2, DSBLOCK_ENTIREBUFFER );
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DSASSERT( FALSE );
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Lock() failed hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
|
|
hr = lpdsBuffer->UnLock( pvBuffer1, dwBufferSize1, pvBuffer2, dwBufferSize2 );
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DSASSERT( FALSE );
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "UnLock() failed hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
|
|
m_lpds3dBuffer = NULL;
|
|
m_lpAudioPlaybackBuffer = NULL;
|
|
m_lpMixBuffer = NULL;
|
|
|
|
// We always need the looping flag
|
|
dwFlags |= DSBPLAY_LOOPING;
|
|
|
|
m_dwPlayFlags = dwFlags;
|
|
m_dwPriority = dwPriority;
|
|
m_fIgnoreFrame = FALSE;
|
|
m_dwLastWriteTime = GetTickCount();
|
|
m_lpstNext = NULL;
|
|
m_dwNumResets = 0;
|
|
m_dwNumSinceMove = 1;
|
|
m_bCommited = FALSE;
|
|
|
|
m_dvidTarget = dvidTarget;
|
|
m_dwFrameSize = dwFrameSize;
|
|
m_dwBufferSize = dwBufferSize1;
|
|
|
|
// STATSBLOCK: Begin
|
|
Stats_Init();
|
|
// STATSBLOCK: End
|
|
|
|
m_fLastFramePushed = FALSE;
|
|
|
|
m_lpAudioPlaybackBuffer = lpdsBuffer;
|
|
|
|
hr = m_lpAudioPlaybackBuffer->Get3DBuffer(&m_lpds3dBuffer);
|
|
if( FAILED( hr ) )
|
|
{
|
|
DSASSERT( FALSE );
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "QueryInterface failed hr=0x%x", hr );
|
|
}
|
|
|
|
m_dwNextWritePos = 0;
|
|
|
|
if( fEightBit )
|
|
{
|
|
m_fEightBit = TRUE;
|
|
m_dwMixSize = dwFrameSize;
|
|
}
|
|
else
|
|
{
|
|
m_fEightBit = FALSE;
|
|
m_dwMixSize = dwFrameSize / 2;
|
|
}
|
|
|
|
m_lpMixBuffer = new LONG[m_dwMixSize];
|
|
|
|
if( m_lpMixBuffer == NULL )
|
|
{
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "Out of memory" );
|
|
m_lpds3dBuffer->Release();
|
|
m_lpds3dBuffer = NULL;
|
|
return DVERR_OUTOFMEMORY;
|
|
}
|
|
|
|
if (!DNInitializeCriticalSection( &m_csGuard ))
|
|
{
|
|
return DVERR_OUTOFMEMORY;
|
|
}
|
|
|
|
m_fMixed = FALSE;
|
|
|
|
return DV_OK;
|
|
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::AddRef"
|
|
LONG CSoundTarget::AddRef()
|
|
{
|
|
LONG lNewCount;
|
|
|
|
DNEnterCriticalSection( &m_csGuard );
|
|
|
|
DPFX(DPFPREP, DVF_SOUNDTARGET_DEBUG_LEVEL, "SOUNDTARGET: [0x%x] lRefCount %d --> %d", m_dvidTarget, m_lRefCount, m_lRefCount+1 );
|
|
|
|
m_lRefCount++;
|
|
|
|
lNewCount = m_lRefCount;
|
|
|
|
DNLeaveCriticalSection( &m_csGuard );
|
|
|
|
return lNewCount;
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::Release"
|
|
LONG CSoundTarget::Release()
|
|
{
|
|
LONG lNewCount;
|
|
|
|
DNEnterCriticalSection( &m_csGuard );
|
|
|
|
DNASSERT( m_lRefCount > 0 );
|
|
|
|
DPFX(DPFPREP, DVF_SOUNDTARGET_DEBUG_LEVEL, "SOUNDTARGET: [0x%x] lRefCount %d --> %d", m_dvidTarget, m_lRefCount, m_lRefCount-1 );
|
|
|
|
m_lRefCount--;
|
|
|
|
lNewCount = m_lRefCount;
|
|
|
|
DNLeaveCriticalSection( &m_csGuard );
|
|
|
|
// Reference reaches 0, destroy!
|
|
if( lNewCount == 0 )
|
|
{
|
|
DPFX(DPFPREP, DVF_SOUNDTARGET_DEBUG_LEVEL, "SOUNDTARGET: [0x%x] DESTROYING", m_dvidTarget, m_lRefCount, m_lRefCount+1 );
|
|
delete this;
|
|
}
|
|
|
|
return lNewCount;
|
|
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSoundTarget::StartMix"
|
|
//
|
|
// StartMix
|
|
//
|
|
// Called ONCE only.
|
|
//
|
|
// Call this function right before you wish to perform the first mix on the buffer.
|
|
// Initializes the object to match the current state of the associated directsound
|
|
// buffer
|
|
//
|
|
HRESULT CSoundTarget::StartMix()
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = m_lpAudioPlaybackBuffer->GetCurrentPosition( &m_dwWritePos );
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
DSASSERT( FALSE );
|
|
DPFX(DPFPREP, DVF_ERRORLEVEL, "GetCurrentPosition Failed hr=0x%x", hr );
|
|
return hr;
|
|
}
|
|
|
|
m_dwNextWritePos = m_dwWritePos + (m_dwFrameSize*SOUNDTARGET_WRITEAHEAD);
|
|
m_dwNextWritePos %= m_dwBufferSize;
|
|
|
|
m_dwLastWritePos = m_dwWritePos;
|
|
|
|
// STATBLOCK: Begin
|
|
Stats_Begin();
|
|
// STATBLOCK: End
|
|
|
|
return DV_OK;
|
|
}
|
|
|
|
void CSoundTarget::GetStats( PlaybackStats *statPlayback )
|
|
{
|
|
memcpy( statPlayback, &m_statPlay, sizeof( PlaybackStats ) );
|
|
}
|
|
|
|
void CSoundTarget::Stats_Init()
|
|
{
|
|
memset( &m_statPlay, 0x00, sizeof( PlaybackStats ) );
|
|
|
|
m_statPlay.m_dwFrameSize = m_dwFrameSize;
|
|
m_statPlay.m_dwBufferSize = m_dwBufferSize;
|
|
|
|
m_statPlay.m_dwPMMSMin = 0xFFFFFFFF;
|
|
m_statPlay.m_dwPMBMin = 0xFFFFFFFF;
|
|
m_statPlay.m_dwPLMin = 0xFFFFFFFF;
|
|
m_statPlay.m_dwTimeStart = GetTickCount();
|
|
}
|
|
|
|
void CSoundTarget::Stats_Begin()
|
|
{
|
|
m_statPlay.m_dwStartLag = GetTickCount() - m_statPlay.m_dwTimeStart;
|
|
}
|
|
|
|
void CSoundTarget::Stats_End()
|
|
{
|
|
char tmpBuffer[200];
|
|
|
|
m_statPlay.m_dwTimeStop = GetTickCount();
|
|
|
|
DWORD dwPlayRunLength = m_statPlay.m_dwTimeStop - m_statPlay.m_dwTimeStart;
|
|
|
|
if( dwPlayRunLength == 0 )
|
|
dwPlayRunLength = 1;
|
|
|
|
DWORD dwNumInternalRuns = m_statPlay.m_dwNumRuns;
|
|
|
|
if( dwNumInternalRuns == 0 )
|
|
dwNumInternalRuns = 1;
|
|
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "--- PLAYBACK BUFFER STATISTICS --------------------------------------[End]" );
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Buffer for ID : 0x%x", m_dvidTarget );
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Play Run Length (ms) : %u", dwPlayRunLength );
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Start Lag : %u", m_statPlay.m_dwStartLag );
|
|
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Speech Size (Uncomp.) : %u", m_statPlay.m_dwFrameSize );
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Frames / Buffer : %u", m_statPlay.m_dwBufferSize / m_statPlay.m_dwFrameSize);
|
|
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "# of wakeups : %u", m_statPlay.m_dwNumRuns );
|
|
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Ignored Frames (Speech): %u", m_statPlay.m_dwPIgnore );
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Ignored Frames (Silent): %u", m_statPlay.m_dwSIgnore );
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Mixed Frames (Speech) : %u", m_statPlay.m_dwNumMixed );
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Mixed Frames (Silent) : %u", m_statPlay.m_dwNumSilentMixed );
|
|
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Punted Frames : %u", m_statPlay.m_dwPPunts );
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Audio Glitches : %u", m_statPlay.m_dwGlitches );
|
|
|
|
sprintf( tmpBuffer, "Play Movement (ms) : Avg: %u [%u..%u]",
|
|
m_statPlay.m_dwPMMSTotal / dwNumInternalRuns,
|
|
m_statPlay.m_dwPMMSMin,
|
|
m_statPlay.m_dwPMMSMax );
|
|
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer );
|
|
|
|
sprintf( tmpBuffer, "Play Movement (bytes) : Avg: %u [%u..%u]",
|
|
m_statPlay.m_dwPMBTotal / dwNumInternalRuns,
|
|
m_statPlay.m_dwPMBMin,
|
|
m_statPlay.m_dwPMBMax );
|
|
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer );
|
|
|
|
sprintf( tmpBuffer, "Play Movement (frames) : Avg: %.2f [%.2f..%.2f]",
|
|
(((float) m_statPlay.m_dwPMBTotal) / ((float) dwNumInternalRuns)) / ((float) m_statPlay.m_dwFrameSize),
|
|
((float) m_statPlay.m_dwPMBMin) / ((float) m_statPlay.m_dwFrameSize),
|
|
((float) m_statPlay.m_dwPMBMax) / ((float) m_statPlay.m_dwFrameSize) );
|
|
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer );
|
|
|
|
sprintf( tmpBuffer, "Play Lead (bytes) : Avg: %u [%u..%u]",
|
|
m_statPlay.m_dwPLTotal / dwNumInternalRuns,
|
|
m_statPlay.m_dwPLMin ,
|
|
m_statPlay.m_dwPLMax );
|
|
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer );
|
|
|
|
sprintf( tmpBuffer, "Play Lag (frames) : Avg: %.2f [%.2f..%.2f]",
|
|
(float) ((float) m_statPlay.m_dwPLTotal / (float) dwNumInternalRuns) / ((float) m_statPlay.m_dwFrameSize),
|
|
(float) ((float) m_statPlay.m_dwPLMin) / (float) m_statPlay.m_dwFrameSize,
|
|
(float) ((float) m_statPlay.m_dwPLMax) / (float) m_statPlay.m_dwFrameSize );
|
|
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer );
|
|
|
|
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "--- PLAYBACK BUFFER STATISTICS ------------------------------------[Begin]" );
|
|
}
|
|
|
|
|
|
HRESULT CSoundTarget::GetCurrentLead( PDWORD pdwLead )
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = m_lpAudioPlaybackBuffer->GetCurrentPosition( &m_dwWritePos );
|
|
|
|
if( m_dwNextWritePos < m_dwWritePos )
|
|
{
|
|
*pdwLead = (m_dwBufferSize-m_dwWritePos) + m_dwNextWritePos;
|
|
}
|
|
else
|
|
{
|
|
*pdwLead = m_dwNextWritePos - m_dwWritePos;
|
|
}
|
|
|
|
return DV_OK;
|
|
|
|
}
|
|
|
|
LPDIRECTSOUND3DBUFFER CSoundTarget::Get3DBuffer()
|
|
{
|
|
m_lpDummy = m_lpds3dBuffer;
|
|
return m_lpds3dBuffer;
|
|
}
|
|
|