938 lines
22 KiB
C++
938 lines
22 KiB
C++
|
#include <objbase.h>
|
||
|
|
#include <windowsx.h>
|
||
|
|
#include <mmsystem.h>
|
||
|
|
#include <dsoundp.h>
|
||
|
|
//#include "debug.h"
|
||
|
|
|
||
|
|
#include "debug.h"
|
||
|
|
#include "dmusicc.h"
|
||
|
|
#include "dmusici.h"
|
||
|
|
#include "dmusicf.h"
|
||
|
|
#include "validate.h"
|
||
|
|
#include "riff.h"
|
||
|
|
#include "dswave.h"
|
||
|
|
#include "riff.h"
|
||
|
|
#include <regstr.h>
|
||
|
|
#include <share.h>
|
||
|
|
#include "waveutil.h"
|
||
|
|
#include "dmstrm.h"
|
||
|
|
|
||
|
|
// seeks to a 32-bit position in a stream.
|
||
|
|
HRESULT __inline StreamSeek( LPSTREAM pStream, long lSeekTo, DWORD dwOrigin )
|
||
|
|
{
|
||
|
|
LARGE_INTEGER li;
|
||
|
|
|
||
|
|
if( lSeekTo < 0 )
|
||
|
|
{
|
||
|
|
li.HighPart = -1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
li.HighPart = 0;
|
||
|
|
}
|
||
|
|
li.LowPart = lSeekTo;
|
||
|
|
return pStream->Seek( li, dwOrigin, NULL );
|
||
|
|
}
|
||
|
|
|
||
|
|
// returns the current 32-bit position in a stream.
|
||
|
|
DWORD __inline StreamTell( LPSTREAM pStream )
|
||
|
|
{
|
||
|
|
LARGE_INTEGER li;
|
||
|
|
ULARGE_INTEGER ul;
|
||
|
|
#ifdef DBG
|
||
|
|
HRESULT hr;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
li.HighPart = 0;
|
||
|
|
li.LowPart = 0;
|
||
|
|
#ifdef DBG
|
||
|
|
hr = pStream->Seek( li, STREAM_SEEK_CUR, &ul );
|
||
|
|
if( FAILED( hr ) )
|
||
|
|
#else
|
||
|
|
if( FAILED( pStream->Seek( li, STREAM_SEEK_CUR, &ul ) ) )
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
return ul.LowPart;
|
||
|
|
}
|
||
|
|
|
||
|
|
CWave::CWave() : m_dwDecompressedStart(0)
|
||
|
|
{
|
||
|
|
V_INAME(CWave::CWave);
|
||
|
|
|
||
|
|
InterlockedIncrement(&g_cComponent);
|
||
|
|
|
||
|
|
InitializeCriticalSection(&m_CriticalSection);
|
||
|
|
|
||
|
|
m_pwfx = NULL;
|
||
|
|
m_pwfxDst = NULL;
|
||
|
|
m_fdwFlags = 0;
|
||
|
|
m_fdwOptions = 0;
|
||
|
|
m_cSamples = 0L;
|
||
|
|
m_pStream = NULL;
|
||
|
|
m_rtReadAheadTime = 0;
|
||
|
|
|
||
|
|
m_cRef = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
CWave::~CWave()
|
||
|
|
{
|
||
|
|
V_INAME(CWave::~CWave);
|
||
|
|
|
||
|
|
if (NULL != m_pwfx)
|
||
|
|
{
|
||
|
|
GlobalFreePtr(m_pwfx);
|
||
|
|
}
|
||
|
|
if (NULL != m_pwfxDst)
|
||
|
|
{
|
||
|
|
GlobalFreePtr(m_pwfxDst);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (m_pStream) m_pStream->Release();
|
||
|
|
|
||
|
|
DeleteCriticalSection(&m_CriticalSection);
|
||
|
|
|
||
|
|
InterlockedDecrement(&g_cComponent);
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::QueryInterface
|
||
|
|
(
|
||
|
|
const IID &iid,
|
||
|
|
void **ppv
|
||
|
|
)
|
||
|
|
{
|
||
|
|
V_INAME(CWave::QueryInterface);
|
||
|
|
V_REFGUID(iid);
|
||
|
|
V_PTRPTR_WRITE(ppv);
|
||
|
|
|
||
|
|
if (iid == IID_IUnknown || iid == IID_IDirectSoundWave)
|
||
|
|
{
|
||
|
|
*ppv = static_cast<IDirectSoundWave*>(this);
|
||
|
|
}
|
||
|
|
else if (iid == IID_IPersistStream)
|
||
|
|
{
|
||
|
|
*ppv = static_cast<IPersistStream*>(this);
|
||
|
|
}
|
||
|
|
else if (iid == IID_IDirectMusicObject)
|
||
|
|
{
|
||
|
|
*ppv = static_cast<IDirectMusicObject*>(this);
|
||
|
|
}
|
||
|
|
else if (iid == IID_IPrivateWave)
|
||
|
|
{
|
||
|
|
*ppv = static_cast<IPrivateWave*>(this);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*ppv = NULL;
|
||
|
|
Trace(4,"Warning: Request to query unknown interface on Wave Object\n");
|
||
|
|
return E_NOINTERFACE;
|
||
|
|
}
|
||
|
|
reinterpret_cast<IUnknown*>(this)->AddRef();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP_(ULONG) CWave::AddRef()
|
||
|
|
{
|
||
|
|
V_INAME(CWave::AddRef);
|
||
|
|
|
||
|
|
return InterlockedIncrement(&m_cRef);
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP_(ULONG) CWave::Release()
|
||
|
|
{
|
||
|
|
V_INAME(CWave::Release);
|
||
|
|
|
||
|
|
if (!InterlockedDecrement(&m_cRef))
|
||
|
|
{
|
||
|
|
delete this;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return m_cRef;
|
||
|
|
}
|
||
|
|
|
||
|
|
static inline HRESULT MMRESULTToHRESULT(
|
||
|
|
MMRESULT mmr)
|
||
|
|
{
|
||
|
|
switch (mmr)
|
||
|
|
{
|
||
|
|
case MMSYSERR_NOERROR:
|
||
|
|
return S_OK;
|
||
|
|
|
||
|
|
case MMSYSERR_ALLOCATED:
|
||
|
|
return DSERR_ALLOCATED;
|
||
|
|
|
||
|
|
case MMSYSERR_NOMEM:
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
|
||
|
|
case MMSYSERR_INVALFLAG:
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
case MMSYSERR_INVALHANDLE:
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
case MMSYSERR_INVALPARAM:
|
||
|
|
return E_INVALIDARG;
|
||
|
|
}
|
||
|
|
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::GetFormat
|
||
|
|
(
|
||
|
|
LPWAVEFORMATEX pwfx,
|
||
|
|
DWORD dwSizeAllocated,
|
||
|
|
LPDWORD pdwSizeWritten
|
||
|
|
)
|
||
|
|
{
|
||
|
|
DWORD cbSize;
|
||
|
|
LPWAVEFORMATEX pwfxTemp = NULL;
|
||
|
|
|
||
|
|
V_INAME(CWave::GetFormat);
|
||
|
|
|
||
|
|
if (!pwfx && !pdwSizeWritten)
|
||
|
|
{
|
||
|
|
Trace(1, "ERROR: GetFormat (Wave): Must request either the format or the required size\n.");
|
||
|
|
return E_INVALIDARG;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!m_pwfx)
|
||
|
|
{
|
||
|
|
return DSERR_BADFORMAT;
|
||
|
|
}
|
||
|
|
if (WAVE_FORMAT_PCM == m_pwfx->wFormatTag)
|
||
|
|
{
|
||
|
|
pwfxTemp = m_pwfx;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pwfxTemp = m_pwfxDst;
|
||
|
|
if (!pwfxTemp)
|
||
|
|
{
|
||
|
|
return DSERR_BADFORMAT;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Note: Assuming that the wave object fills the cbSize field even
|
||
|
|
// on PCM formats...
|
||
|
|
|
||
|
|
if (WAVE_FORMAT_PCM == pwfxTemp->wFormatTag)
|
||
|
|
{
|
||
|
|
cbSize = sizeof(PCMWAVEFORMAT);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
cbSize = sizeof(WAVEFORMATEX) + pwfxTemp->cbSize;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (cbSize > dwSizeAllocated || !pwfx)
|
||
|
|
{
|
||
|
|
if (pdwSizeWritten)
|
||
|
|
{
|
||
|
|
*pdwSizeWritten = cbSize;
|
||
|
|
return S_OK; // What to return?
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return DSERR_INVALIDPARAM;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// We don't validate this parameter any earlier on the off chance
|
||
|
|
// that they're doing a query...
|
||
|
|
|
||
|
|
V_BUFPTR_WRITE(pwfx, dwSizeAllocated);
|
||
|
|
|
||
|
|
CopyMemory(pwfx, pwfxTemp, cbSize);
|
||
|
|
|
||
|
|
// Set the cbSize field in destination for PCM, IF WE HAVE ROOM...
|
||
|
|
|
||
|
|
if (WAVE_FORMAT_PCM == pwfxTemp->wFormatTag)
|
||
|
|
{
|
||
|
|
if (sizeof(WAVEFORMATEX) <= dwSizeAllocated)
|
||
|
|
{
|
||
|
|
pwfx->cbSize = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Return the numbers of bytes actually writted
|
||
|
|
if (pdwSizeWritten)
|
||
|
|
{
|
||
|
|
*pdwSizeWritten = cbSize;
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::CreateSource
|
||
|
|
(
|
||
|
|
IDirectSoundSource **ppSource,
|
||
|
|
LPWAVEFORMATEX pwfx,
|
||
|
|
DWORD fdwFlags
|
||
|
|
)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
CWaveViewPort* pVP;
|
||
|
|
CREATEVIEWPORT cvp;
|
||
|
|
|
||
|
|
V_INAME(CWave::CreateSource);
|
||
|
|
V_PTRPTR_WRITE(ppSource);
|
||
|
|
V_PWFX_READ(pwfx);
|
||
|
|
|
||
|
|
DWORD dwCreateFlags = 0;
|
||
|
|
if (fdwFlags == DMUS_DOWNLOADINFO_ONESHOTWAVE)
|
||
|
|
{
|
||
|
|
dwCreateFlags |= DSOUND_WAVEF_ONESHOT;
|
||
|
|
}
|
||
|
|
if (dwCreateFlags & (~DSOUND_WAVEF_CREATEMASK))
|
||
|
|
{
|
||
|
|
Trace(1, "ERROR: CreateSource (Wave): Unknown flag.\n");
|
||
|
|
return (E_INVALIDARG);
|
||
|
|
}
|
||
|
|
|
||
|
|
TraceI(5, "CWave::CreateSource [%d samples]\n", m_cSamples);
|
||
|
|
|
||
|
|
pVP = new CWaveViewPort;
|
||
|
|
if (!pVP)
|
||
|
|
{
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
}
|
||
|
|
|
||
|
|
cvp.pStream = m_pStream;
|
||
|
|
cvp.cSamples = m_cSamples;
|
||
|
|
cvp.dwDecompressedStart = m_dwDecompressedStart;
|
||
|
|
cvp.cbStream = m_cbStream;
|
||
|
|
cvp.pwfxSource = m_pwfx;
|
||
|
|
cvp.pwfxTarget = pwfx;
|
||
|
|
cvp.fdwOptions = dwCreateFlags;
|
||
|
|
|
||
|
|
hr = pVP->Create(&cvp);
|
||
|
|
|
||
|
|
if (SUCCEEDED(hr))
|
||
|
|
{
|
||
|
|
hr = pVP->QueryInterface(IID_IDirectSoundSource, (void **)ppSource);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
TraceI(5, "CWave::CreateSource 00\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
if (SUCCEEDED(hr))
|
||
|
|
{
|
||
|
|
// The QI gave us one ref too many
|
||
|
|
pVP->Release();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
TraceI(5, "CWave::CreateSource 01\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::GetStreamingParms
|
||
|
|
(
|
||
|
|
LPDWORD pdwFlags,
|
||
|
|
LPREFERENCE_TIME prtReadAhead
|
||
|
|
)
|
||
|
|
{
|
||
|
|
V_INAME(IDirectSoundWave::GetStreamingParms);
|
||
|
|
V_PTR_WRITE(pdwFlags, DWORD);
|
||
|
|
V_PTR_WRITE(prtReadAhead, REFERENCE_TIME);
|
||
|
|
|
||
|
|
*pdwFlags = 0;
|
||
|
|
|
||
|
|
if(!(m_fdwFlags & DSOUND_WAVEF_ONESHOT))
|
||
|
|
{
|
||
|
|
*pdwFlags |= DMUS_WAVEF_STREAMING;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(m_fdwFlags & DMUS_WAVEF_NOPREROLL)
|
||
|
|
{
|
||
|
|
*pdwFlags |= DMUS_WAVEF_NOPREROLL;
|
||
|
|
}
|
||
|
|
|
||
|
|
*prtReadAhead = m_rtReadAheadTime;
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::GetClassID
|
||
|
|
(
|
||
|
|
CLSID* pClsId
|
||
|
|
)
|
||
|
|
{
|
||
|
|
V_INAME(CWave::GetClassID);
|
||
|
|
V_PTR_WRITE(pClsId, CLSID);
|
||
|
|
|
||
|
|
*pClsId = CLSID_DirectSoundWave;
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::IsDirty()
|
||
|
|
{
|
||
|
|
V_INAME(CWave::IsDirty);
|
||
|
|
|
||
|
|
return S_FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL CWave::ParseHeader
|
||
|
|
(
|
||
|
|
IStream* pIStream,
|
||
|
|
IRIFFStream* pIRiffStream,
|
||
|
|
LPMMCKINFO pckMain
|
||
|
|
)
|
||
|
|
{
|
||
|
|
MMCKINFO ck;
|
||
|
|
DWORD cb = 0;
|
||
|
|
DWORD dwPos = 0;
|
||
|
|
MMCKINFO ckINFO;
|
||
|
|
HRESULT hr;
|
||
|
|
|
||
|
|
ck.ckid = 0;
|
||
|
|
ck.fccType = 0;
|
||
|
|
|
||
|
|
V_INAME(CWave::ParseHeader);
|
||
|
|
|
||
|
|
BOOL fFormat = FALSE;
|
||
|
|
BOOL fData = FALSE;
|
||
|
|
BOOL fHeader = FALSE;
|
||
|
|
BOOL fReadDecompressionFmt = FALSE;
|
||
|
|
DWORD dwSamplesFromFact = 0;
|
||
|
|
|
||
|
|
while (0 == pIRiffStream->Descend(&ck, pckMain, MMIO_FINDCHUNK))
|
||
|
|
{
|
||
|
|
switch (ck.ckid)
|
||
|
|
{
|
||
|
|
case mmioFOURCC('w','a','v','u') :
|
||
|
|
{
|
||
|
|
cb = 0;
|
||
|
|
bool bRuntime = false;
|
||
|
|
hr = pIStream->Read(&bRuntime, sizeof(bool), &cb);
|
||
|
|
if(FAILED(hr) || cb != sizeof(bool))
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
cb = 0;
|
||
|
|
bool bCompressed = false;
|
||
|
|
hr = pIStream->Read(&bCompressed, sizeof(bool), &cb);
|
||
|
|
if(FAILED(hr) || cb != sizeof(bool))
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(bRuntime && bCompressed)
|
||
|
|
{
|
||
|
|
// If we have already allocated m_pwfxDst, delete it first
|
||
|
|
if (NULL != m_pwfxDst)
|
||
|
|
{
|
||
|
|
GlobalFreePtr(m_pwfxDst);
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pwfxDst = (LPWAVEFORMATEX)GlobalAllocPtr(GHND, sizeof(WAVEFORMATEX));
|
||
|
|
if (NULL == m_pwfxDst)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
cb = 0;
|
||
|
|
hr = pIStream->Read(m_pwfxDst, sizeof(WAVEFORMATEX), &cb);
|
||
|
|
if(FAILED(hr) || cb != sizeof(WAVEFORMATEX))
|
||
|
|
{
|
||
|
|
GlobalFreePtr(m_pwfxDst);
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Read the actual start for the decompressed data if available
|
||
|
|
// This is very important for MP3 and WMA codecs which insert silence in the beginning
|
||
|
|
if(ck.cksize > 2 + sizeof(WAVEFORMATEX))
|
||
|
|
{
|
||
|
|
cb = 0;
|
||
|
|
hr = pIStream->Read(&m_dwDecompressedStart, sizeof(DWORD), &cb);
|
||
|
|
if(FAILED(hr) || cb != sizeof(DWORD))
|
||
|
|
{
|
||
|
|
GlobalFreePtr(m_pwfxDst);
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fReadDecompressionFmt = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case DMUS_FOURCC_WAVEHEADER_CHUNK:
|
||
|
|
{
|
||
|
|
m_fdwFlags = 0;
|
||
|
|
fHeader = TRUE;
|
||
|
|
DMUS_IO_WAVE_HEADER iWaveHeader;
|
||
|
|
memset(&iWaveHeader, 0, sizeof(iWaveHeader));
|
||
|
|
hr = pIStream->Read(&iWaveHeader, sizeof(iWaveHeader), &cb);
|
||
|
|
if (iWaveHeader.dwFlags & DMUS_WAVEF_STREAMING)
|
||
|
|
{
|
||
|
|
m_fdwFlags &= ~DSOUND_WAVEF_ONESHOT;
|
||
|
|
m_rtReadAheadTime = iWaveHeader.rtReadAhead;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_fdwFlags |= DSOUND_WAVEF_ONESHOT;
|
||
|
|
m_rtReadAheadTime = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (iWaveHeader.dwFlags & DMUS_WAVEF_NOPREROLL)
|
||
|
|
{
|
||
|
|
m_fdwFlags |= DMUS_WAVEF_NOPREROLL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_fdwFlags &= ~DMUS_WAVEF_NOPREROLL;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case DMUS_FOURCC_GUID_CHUNK:
|
||
|
|
hr = pIStream->Read(&m_guid, sizeof(GUID), &cb);
|
||
|
|
m_fdwOptions |= DMUS_OBJ_OBJECT;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case DMUS_FOURCC_VERSION_CHUNK:
|
||
|
|
hr = pIStream->Read( &m_vVersion, sizeof(DMUS_VERSION), &cb );
|
||
|
|
m_fdwOptions |= DMUS_OBJ_VERSION;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case FOURCC_LIST:
|
||
|
|
switch(ck.fccType)
|
||
|
|
{
|
||
|
|
case DMUS_FOURCC_INFO_LIST:
|
||
|
|
while( pIRiffStream->Descend( &ckINFO, &ck, 0 ) == 0 )
|
||
|
|
{
|
||
|
|
switch(ckINFO.ckid)
|
||
|
|
{
|
||
|
|
case mmioFOURCC('I','N','A','M'):
|
||
|
|
{
|
||
|
|
DWORD cbSize;
|
||
|
|
cbSize = min(ckINFO.cksize, DMUS_MAX_NAME);
|
||
|
|
char szName[DMUS_MAX_NAME];
|
||
|
|
hr = pIStream->Read((BYTE*)szName, cbSize, &cb);
|
||
|
|
if(SUCCEEDED(hr))
|
||
|
|
{
|
||
|
|
MultiByteToWideChar(CP_ACP, 0, szName, -1, m_wszFilename, DMUS_MAX_NAME);
|
||
|
|
m_fdwOptions |= DMUS_OBJ_NAME;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
pIRiffStream->Ascend( &ckINFO, 0 );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case mmioFOURCC('f','m','t',' '):
|
||
|
|
{
|
||
|
|
// If we have already allocated m_pwfx, delete it first
|
||
|
|
if (NULL != m_pwfx)
|
||
|
|
{
|
||
|
|
GlobalFreePtr(m_pwfx);
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pwfx = (LPWAVEFORMATEX)GlobalAllocPtr(GHND, max (sizeof(WAVEFORMATEX), ck.cksize));
|
||
|
|
|
||
|
|
if (NULL == m_pwfx)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
hr = pIStream->Read(m_pwfx, ck.cksize, &cb);
|
||
|
|
|
||
|
|
if (S_OK != hr)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (m_pwfx && WAVE_FORMAT_PCM != m_pwfx->wFormatTag)
|
||
|
|
{
|
||
|
|
if(fReadDecompressionFmt == FALSE)
|
||
|
|
{
|
||
|
|
// If we have already allocated m_pwfxDst, delete it first
|
||
|
|
if (NULL != m_pwfxDst)
|
||
|
|
{
|
||
|
|
GlobalFreePtr(m_pwfxDst);
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pwfxDst = (LPWAVEFORMATEX)GlobalAllocPtr(GHND, sizeof(WAVEFORMATEX));
|
||
|
|
if (NULL == m_pwfxDst)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
m_pwfxDst->wFormatTag = WAVE_FORMAT_PCM;
|
||
|
|
|
||
|
|
MMRESULT mmr = acmFormatSuggest(NULL, m_pwfx, m_pwfxDst, sizeof(WAVEFORMATEX), ACM_FORMATSUGGESTF_WFORMATTAG);
|
||
|
|
if(MMSYSERR_NOERROR != mmr)
|
||
|
|
{
|
||
|
|
GlobalFreePtr(m_pwfxDst);
|
||
|
|
m_pwfxDst = NULL;
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fFormat = TRUE;
|
||
|
|
TraceI(5, "Format [%d:%d%c%02d]\n", m_pwfx->wFormatTag, m_pwfx->nSamplesPerSec/1000, ((2==m_pwfx->nChannels)?'S':'M'), m_pwfx->wBitsPerSample);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case mmioFOURCC('f','a','c','t'):
|
||
|
|
hr = pIStream->Read(&dwSamplesFromFact, sizeof(DWORD), &cb);
|
||
|
|
TraceI(5, "Stream is %d samples\n", dwSamplesFromFact);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case mmioFOURCC('d','a','t','a'):
|
||
|
|
TraceI(5, "Data chunk %d bytes\n", ck.cksize);
|
||
|
|
m_cbStream = ck.cksize;
|
||
|
|
|
||
|
|
fData = TRUE;
|
||
|
|
if (!fHeader) FallbackStreamingBehavior();
|
||
|
|
|
||
|
|
// save stream position so we can seek back later
|
||
|
|
dwPos = StreamTell( pIStream );
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
pIRiffStream->Ascend(&ck, 0);
|
||
|
|
ck.ckid = 0;
|
||
|
|
ck.fccType = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (m_pwfx && WAVE_FORMAT_PCM != m_pwfx->wFormatTag && dwSamplesFromFact)
|
||
|
|
{
|
||
|
|
m_cSamples = dwSamplesFromFact;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!fHeader) FallbackStreamingBehavior();
|
||
|
|
|
||
|
|
// Seek to beginning of data
|
||
|
|
if (fData)
|
||
|
|
{
|
||
|
|
StreamSeek(pIStream, dwPos, STREAM_SEEK_SET);
|
||
|
|
}
|
||
|
|
return fFormat && fData;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::Load
|
||
|
|
(
|
||
|
|
IStream* pIStream
|
||
|
|
)
|
||
|
|
{
|
||
|
|
IRIFFStream* pIRiffStream = NULL;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
V_INAME(CWave::Load);
|
||
|
|
|
||
|
|
if (NULL == pIStream)
|
||
|
|
{
|
||
|
|
Trace(1, "ERROR: Load (Wave): Attempt to load from null stream.\n");
|
||
|
|
return E_INVALIDARG;
|
||
|
|
}
|
||
|
|
|
||
|
|
EnterCriticalSection( &m_CriticalSection );
|
||
|
|
|
||
|
|
if (SUCCEEDED(AllocRIFFStream(pIStream, &pIRiffStream)))
|
||
|
|
{
|
||
|
|
MMCKINFO ckMain;
|
||
|
|
|
||
|
|
ckMain.fccType = mmioFOURCC('W','A','V','E');
|
||
|
|
|
||
|
|
if (0 != pIRiffStream->Descend(&ckMain, NULL, MMIO_FINDRIFF))
|
||
|
|
{
|
||
|
|
Trace(1, "ERROR: Load (Wave): Stream does not contain a wave chunk.\n");
|
||
|
|
hr = E_INVALIDARG;
|
||
|
|
goto ON_END;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parses the header information and seeks to the beginning
|
||
|
|
// of the data in the data chunk.
|
||
|
|
|
||
|
|
if (0 == ParseHeader(pIStream, pIRiffStream, &ckMain))
|
||
|
|
{
|
||
|
|
Trace(1, "ERROR: Load (Wave): Attempt to read wave's header information failed.\n");
|
||
|
|
hr = E_INVALIDARG;
|
||
|
|
goto ON_END;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (0 == m_cSamples)
|
||
|
|
{
|
||
|
|
if (m_pwfx && WAVE_FORMAT_PCM == m_pwfx->wFormatTag)
|
||
|
|
{
|
||
|
|
m_cSamples = m_cbStream / m_pwfx->nBlockAlign;
|
||
|
|
}
|
||
|
|
else // wave format not supported
|
||
|
|
{
|
||
|
|
hr = DSERR_BADFORMAT;
|
||
|
|
goto ON_END;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pIStream->AddRef();
|
||
|
|
if (m_pStream)
|
||
|
|
{
|
||
|
|
m_pStream->Release();
|
||
|
|
}
|
||
|
|
m_pStream = pIStream;
|
||
|
|
|
||
|
|
ON_END:
|
||
|
|
if (pIRiffStream) pIRiffStream->Release();
|
||
|
|
LeaveCriticalSection( &m_CriticalSection );
|
||
|
|
TraceI(5, "CWave::Load01\n");
|
||
|
|
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::Save
|
||
|
|
(
|
||
|
|
IStream* pIStream,
|
||
|
|
BOOL fClearDirty
|
||
|
|
)
|
||
|
|
{
|
||
|
|
V_INAME(CWave::Save);
|
||
|
|
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::GetSizeMax
|
||
|
|
(
|
||
|
|
ULARGE_INTEGER FAR* pcbSize
|
||
|
|
)
|
||
|
|
{
|
||
|
|
V_INAME(CWave::GetSizeMax);
|
||
|
|
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::GetDescriptor
|
||
|
|
(
|
||
|
|
LPDMUS_OBJECTDESC pDesc
|
||
|
|
)
|
||
|
|
{
|
||
|
|
// Parameter validation...
|
||
|
|
|
||
|
|
V_INAME(CWave::GetDescriptor);
|
||
|
|
V_STRUCTPTR_WRITE(pDesc, DMUS_OBJECTDESC)
|
||
|
|
|
||
|
|
ZeroMemory(pDesc, sizeof(DMUS_OBJECTDESC));
|
||
|
|
|
||
|
|
pDesc->dwSize = sizeof(DMUS_OBJECTDESC);
|
||
|
|
pDesc->dwValidData = DMUS_OBJ_CLASS;
|
||
|
|
pDesc->guidClass = CLSID_DirectSoundWave;
|
||
|
|
|
||
|
|
if (NULL != m_pwfx)
|
||
|
|
{
|
||
|
|
pDesc->dwValidData |= DMUS_OBJ_LOADED;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (m_fdwOptions & DMUS_OBJ_OBJECT)
|
||
|
|
{
|
||
|
|
pDesc->guidObject = m_guid;
|
||
|
|
pDesc->dwValidData |= DMUS_OBJ_OBJECT;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (m_fdwOptions & DMUS_OBJ_NAME)
|
||
|
|
{
|
||
|
|
memcpy( pDesc->wszName, m_wszFilename, sizeof(m_wszFilename) );
|
||
|
|
pDesc->dwValidData |= DMUS_OBJ_NAME;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (m_fdwOptions & DMUS_OBJ_VERSION)
|
||
|
|
{
|
||
|
|
pDesc->vVersion.dwVersionMS = m_vVersion.dwVersionMS;
|
||
|
|
pDesc->vVersion.dwVersionLS = m_vVersion.dwVersionLS;
|
||
|
|
pDesc->dwValidData |= DMUS_OBJ_VERSION;
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::SetDescriptor
|
||
|
|
(
|
||
|
|
LPDMUS_OBJECTDESC pDesc
|
||
|
|
)
|
||
|
|
{
|
||
|
|
HRESULT hr = E_INVALIDARG;
|
||
|
|
DWORD dw = 0;
|
||
|
|
|
||
|
|
// Parameter validation...
|
||
|
|
|
||
|
|
V_INAME(CWave::SetDescriptor);
|
||
|
|
V_PTR_READ(pDesc, DMUS_OBJECTDESC)
|
||
|
|
|
||
|
|
if (pDesc->dwSize >= sizeof(DMUS_OBJECTDESC))
|
||
|
|
{
|
||
|
|
if(pDesc->dwValidData & DMUS_OBJ_CLASS)
|
||
|
|
{
|
||
|
|
dw |= DMUS_OBJ_CLASS;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pDesc->dwValidData & DMUS_OBJ_LOADED)
|
||
|
|
{
|
||
|
|
dw |= DMUS_OBJ_LOADED;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pDesc->dwValidData & DMUS_OBJ_OBJECT)
|
||
|
|
{
|
||
|
|
m_guid = pDesc->guidObject;
|
||
|
|
dw |= DMUS_OBJ_OBJECT;
|
||
|
|
m_fdwOptions |= DMUS_OBJ_OBJECT;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pDesc->dwValidData & DMUS_OBJ_NAME)
|
||
|
|
{
|
||
|
|
memcpy( m_wszFilename, pDesc->wszName, sizeof(WCHAR)*DMUS_MAX_NAME );
|
||
|
|
dw |= DMUS_OBJ_NAME;
|
||
|
|
m_fdwOptions |= DMUS_OBJ_NAME;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pDesc->dwValidData & DMUS_OBJ_VERSION)
|
||
|
|
{
|
||
|
|
m_vVersion.dwVersionMS = pDesc->vVersion.dwVersionMS;
|
||
|
|
m_vVersion.dwVersionLS = pDesc->vVersion.dwVersionLS;
|
||
|
|
dw |= DMUS_OBJ_VERSION;
|
||
|
|
m_fdwOptions |= DMUS_OBJ_VERSION;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pDesc->dwValidData & (~dw))
|
||
|
|
{
|
||
|
|
Trace(2, "WARNING: SetDescriptor (Wave): Descriptor contains fields that were not set.\n");
|
||
|
|
hr = S_FALSE;
|
||
|
|
pDesc->dwValidData = dw;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
hr = S_OK;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::ParseDescriptor
|
||
|
|
(
|
||
|
|
LPSTREAM pStream,
|
||
|
|
LPDMUS_OBJECTDESC pDesc
|
||
|
|
)
|
||
|
|
{
|
||
|
|
V_INAME(CWave::ParseDescriptor);
|
||
|
|
V_PTR_READ(pDesc, DMUS_OBJECTDESC)
|
||
|
|
|
||
|
|
CRiffParser Parser(pStream);
|
||
|
|
RIFFIO ckMain;
|
||
|
|
RIFFIO ckNext;
|
||
|
|
RIFFIO ckINFO;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
Parser.EnterList(&ckMain);
|
||
|
|
if (Parser.NextChunk(&hr) && (ckMain.fccType == mmioFOURCC('W','A','V','E')))
|
||
|
|
{
|
||
|
|
Parser.EnterList(&ckNext);
|
||
|
|
while(Parser.NextChunk(&hr))
|
||
|
|
{
|
||
|
|
switch(ckNext.ckid)
|
||
|
|
{
|
||
|
|
case DMUS_FOURCC_GUID_CHUNK:
|
||
|
|
hr = Parser.Read( &pDesc->guidObject, sizeof(GUID) );
|
||
|
|
if( SUCCEEDED(hr) )
|
||
|
|
{
|
||
|
|
pDesc->dwValidData |= DMUS_OBJ_OBJECT;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case DMUS_FOURCC_VERSION_CHUNK:
|
||
|
|
hr = Parser.Read( &pDesc->vVersion, sizeof(DMUS_VERSION) );
|
||
|
|
if( SUCCEEDED(hr) )
|
||
|
|
{
|
||
|
|
pDesc->dwValidData |= DMUS_OBJ_VERSION;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case FOURCC_LIST:
|
||
|
|
switch(ckNext.fccType)
|
||
|
|
{
|
||
|
|
case DMUS_FOURCC_INFO_LIST:
|
||
|
|
Parser.EnterList(&ckINFO);
|
||
|
|
while (Parser.NextChunk(&hr))
|
||
|
|
{
|
||
|
|
switch( ckINFO.ckid )
|
||
|
|
{
|
||
|
|
case mmioFOURCC('I','N','A','M'):
|
||
|
|
{
|
||
|
|
DWORD cbSize;
|
||
|
|
cbSize = min(ckINFO.cksize, DMUS_MAX_NAME);
|
||
|
|
char szName[DMUS_MAX_NAME];
|
||
|
|
hr = Parser.Read(&szName, sizeof(szName));
|
||
|
|
if(SUCCEEDED(hr))
|
||
|
|
{
|
||
|
|
MultiByteToWideChar(CP_ACP, 0, szName, -1, pDesc->wszName, DMUS_MAX_NAME);
|
||
|
|
pDesc->dwValidData |= DMUS_OBJ_NAME;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Parser.LeaveList();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Parser.LeaveList();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Trace(2, "WARNING: ParseDescriptor (Wave): The stream does not contain a Wave chunk.\n");
|
||
|
|
hr = DMUS_E_CHUNKNOTFOUND;
|
||
|
|
}
|
||
|
|
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CWave::GetLength(REFERENCE_TIME *prtLength)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
if (0 == m_cSamples)
|
||
|
|
{
|
||
|
|
if (m_pwfx && WAVE_FORMAT_PCM == m_pwfx->wFormatTag)
|
||
|
|
{
|
||
|
|
m_cSamples = m_cbStream / m_pwfx->nBlockAlign;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (m_cSamples && m_pwfx && m_pwfx->nSamplesPerSec)
|
||
|
|
{
|
||
|
|
if(m_dwDecompressedStart > 0)
|
||
|
|
{
|
||
|
|
assert(m_dwDecompressedStart < m_cSamples);
|
||
|
|
*prtLength = 1000 * (REFERENCE_TIME)(m_cSamples - m_dwDecompressedStart) / m_pwfx->nSamplesPerSec;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*prtLength = 1000 * (REFERENCE_TIME)m_cSamples / m_pwfx->nSamplesPerSec;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Trace(2, "WARNING: Couldn't get a length for a Wave.\n");
|
||
|
|
hr = DMUS_E_BADWAVE;
|
||
|
|
}
|
||
|
|
return hr;
|
||
|
|
}
|