#include <objbase.h>
#include <windowsx.h>
#include <mmsystem.h>
#include <dsoundp.h>

#include "debug.h" 
#include "dmusicc.h" 
#include "dmusici.h" 
#include "validate.h"
#include "riff.h"
#include "dswave.h"
#include "waveutil.h"
#include "riff.h"
#include <regstr.h>
#include <share.h>

//    CWaveViewPort(IStream *pStream);  // Constructor receives stream.
//    ~CWaveViewPort();                 //  Destructor releases memory, streams, etc.
//
//    STDMETHODIMP Init();
//    STDMETHODIMP GetFormat(LPWAVEFORMATEX pWaveFormatEx, LPDWORD pdwWaveFormatExSize);
//    STDMETHODIMP Seek(DWORD dwSample);
//    STDMETHODIMP Read(LPVOID *ppvBuffer, DWORD cpvBuffer, LPDWORD pcb);


CWaveViewPort::CWaveViewPort() : m_dwDecompressedStart(0), m_dwDecompStartOffset(0), m_dwDecompStartOffsetPCM(0), m_dwDecompStartDelta(0)
{
    V_INAME(CWaveViewPort::CWaveViewPort);

    InterlockedIncrement(&g_cComponent);

    InitializeCriticalSection(&m_CriticalSection);
    // Note: on pre-Blackcomb OS's, this call can raise an exception; if it
    // ever pops in stress, we can add an exception handler and retry loop.

    m_cRef = 1;

    //  General stuff...
    m_pStream    = NULL; 
    m_cSamples   = 0L;
    m_cbStream   = 0L;
    m_dwStart    = 0L;

    //  Viewport info...
    m_pwfxTarget = NULL;
    ZeroMemory(&m_ash, sizeof(ACMSTREAMHEADER));
    m_hStream    = NULL;   
    m_pDst       = NULL;      
    m_pRaw       = NULL;      
    m_fdwOptions = 0L;

    m_dwPreCacheFilePos = 0;
    m_dwFirstPCMSample = 0;
    m_dwPCMSampleOut = 0;

    return;
}


CWaveViewPort::~CWaveViewPort()
{
    V_INAME(CWaveViewPort::~CWaveViewPort);

    if (m_pStream) m_pStream->Release();
    if (m_hStream)
    {
        acmStreamUnprepareHeader(m_hStream, &m_ash, 0L);
        acmStreamClose(m_hStream, 0);
    }
    if (NULL != m_pwfxTarget)
    {
        GlobalFreePtr(m_pwfxTarget);
    }
    if (NULL != m_ash.pbDst)
    {
        GlobalFreePtr(m_ash.pbDst);
    }
    if (NULL != m_ash.pbSrc)
    {
        GlobalFreePtr(m_ash.pbSrc);
    }
    
    DeleteCriticalSection(&m_CriticalSection);

    InterlockedDecrement(&g_cComponent);

    return;
}

STDMETHODIMP CWaveViewPort::QueryInterface
(
    const IID &iid,
    void **ppv
)
{
    V_INAME(CWaveViewPort::QueryInterface);

    if (iid == IID_IUnknown || iid == IID_IDirectSoundSource)
    {
        *ppv = static_cast<IDirectSoundSource*>(this);
    }
    else
    {
        *ppv = NULL;
        Trace(4,"Warning: Request to query unknown interface on Viewport\n");
        return E_NOINTERFACE;
    }
    reinterpret_cast<IUnknown*>(this)->AddRef();
    return S_OK;
}

STDMETHODIMP_(ULONG) CWaveViewPort::AddRef()
{
    V_INAME(CWaveViewPort::AddRef);

    return InterlockedIncrement(&m_cRef);
}

STDMETHODIMP_(ULONG) CWaveViewPort::Release()
{
    V_INAME(CWaveViewPort::Release);

    if (!InterlockedDecrement(&m_cRef))
    {
        delete this;
        return 0;
    }

    return m_cRef;
}

STDMETHODIMP CWaveViewPort::SetSink
(
    IDirectSoundConnect *pSinkConnect
)
{
    V_INAME(CWaveViewPort::Init);
    
    return S_OK;
}

STDMETHODIMP CWaveViewPort::GetFormat
(
    LPWAVEFORMATEX pwfx,
    DWORD dwSizeAllocated,
    LPDWORD pdwSizeWritten
)
{
    DWORD           cbSize;

    V_INAME(CWaveViewPort::GetFormat);

    if (!pwfx && !pdwSizeWritten)
    {
        Trace(1, "ERROR: GetFormat (Viewport): Must request either the format or the required size");
        return E_INVALIDARG;
    }

    if (!m_pwfxTarget)
    {
        return DSERR_BADFORMAT;
    }

    //  Note: Assuming that the wave object fills the cbSize field even
    //  on PCM formats...

    if (WAVE_FORMAT_PCM == m_pwfxTarget->wFormatTag)
    {
        cbSize = sizeof(PCMWAVEFORMAT);
    }
    else
    {
        cbSize = sizeof(WAVEFORMATEX) + m_pwfxTarget->cbSize;
    }

    if (pdwSizeWritten)
    {
        V_PTR_WRITE(pdwSizeWritten, DWORD);
        *pdwSizeWritten = cbSize;
    }

    if (pwfx)
    {
        V_BUFPTR_WRITE(pwfx, dwSizeAllocated);
        if (dwSizeAllocated < cbSize)
        {
            return DSERR_INVALIDPARAM;
        }
        else
        {
            CopyMemory(pwfx, m_pwfxTarget, cbSize);
            // Set the cbSize field in destination if we have room
            if (WAVE_FORMAT_PCM == m_pwfxTarget->wFormatTag && dwSizeAllocated >= sizeof(WAVEFORMATEX))
            {
                pwfx->cbSize = 0;
            }
        }
    }

    return S_OK;
}

STDMETHODIMP CWaveViewPort::Seek
(
    ULONGLONG       ullPosition
)
{
    LARGE_INTEGER   li;
    HRESULT         hr;
    MMRESULT        mmr;
    DWORD           cbSize;

    V_INAME(CWaveViewPort::Seek);

    m_fdwOptions &= ~DSOUND_WVP_STREAMEND; // rsw clear this on seek: no longer at stream end

    if (m_fdwOptions & DSOUND_WVP_NOCONVERT)
    {
        if ((DWORD) ullPosition >= m_cbStream)
        {
            // Seek past end of stream
            //
            m_fdwOptions |= DSOUND_WVP_STREAMEND;
            m_dwOffset = m_cbStream;

            return S_OK;
        }

        m_dwOffset = (DWORD) ullPosition;      // rsw initialize offset to Seek position

        if (0 != (ullPosition % m_pwfxTarget->nBlockAlign))
        {
            //  Seek position not block aligned?

            Trace(1, "ERROR: Seek (wave): Seek position is not block-aligned.\n");
            return (DMUS_E_BADWAVE);
        }

        li.HighPart = 0;
        li.LowPart  = ((DWORD)ullPosition) + m_dwStartPos;

        hr = m_pStream->Seek(li, STREAM_SEEK_SET, NULL);

        if (FAILED(hr))
        {
            Trace(1, "ERROR: Seek (Viewport): Seeking the vieport's stream failed.\n");
            return (DMUS_E_BADWAVE);
        }
    }
    else
    {
        //  Estimating source stream position...
        //
        //  Should we create lookup table?!

        cbSize = (DWORD)ullPosition;

        if (cbSize)
        {
            mmr = acmStreamSize(m_hStream, cbSize, &cbSize, ACM_STREAMSIZEF_DESTINATION);

            if (MMSYSERR_NOERROR != mmr)
            {
                Trace(1, "ERROR: Seek (viewport): Could not convert target stream size to source format.\n");
                return (DMUS_E_BADWAVE);
            }
        }

        if (cbSize >= m_cbStream)
        {
            // Seek past end of stream
            //
            m_fdwOptions |= DSOUND_WVP_STREAMEND;
            m_dwOffset = m_cbStream;

            return S_OK;
        }

        // If this is a seek to the precache end we know where to start reading from
        if((m_fdwOptions & DSOUND_WAVEF_ONESHOT) == 0)
        {
            // Go back to the block that was read for the end of the precached data
            if(cbSize != 0 && m_dwPCMSampleOut == ullPosition)
            {
                m_dwOffset = m_dwPreCacheFilePos;
                li.HighPart = 0;
                li.LowPart  = m_dwOffset + m_dwStartPos;
            }
            else
            {
                m_dwOffset = cbSize; // rsw initialize offset to Seek position
                li.HighPart = 0;
                li.LowPart  = cbSize + m_dwStartPos;

            }

            hr = m_pStream->Seek(li, STREAM_SEEK_SET, NULL);

            if (FAILED(hr))
            {
                Trace(1, "ERROR: Seek (viewport): Seeking the viewport's stream failed.\n");
                return (DMUS_E_BADWAVE);
            }

            // Since we're restarting, re-initialize.
            m_fdwOptions &= (~DSOUND_WVP_CONVERTMASK);
            m_fdwOptions |= DSOUND_WVP_CONVERTSTATE_01;

            m_ash.cbSrcLength     = (DWORD)m_ash.dwSrcUser;
            m_ash.cbSrcLengthUsed = m_ash.cbSrcLength;

            m_ash.dwDstUser       = 0L;
            m_ash.cbDstLengthUsed = 0L;

        }

        /////////////////////////////////////////////////////////////////////////////////////
        // If we're starting the wave, re-seek the stream (one-shots always need to re-seek).
        // NOTE: The following assumes that compressed waves always seek from the beginning,
        // since the value returned by acmStreamSize is pretty unreliable.
        /////////////////////////////////////////////////////////////////////////////////////
        else if ( cbSize == 0 || (m_fdwOptions & DSOUND_WAVEF_ONESHOT) )
        {
        
            m_dwOffset = cbSize; // rsw initialize offset to Seek position
            li.HighPart = 0;
            li.LowPart  = cbSize + m_dwStartPos;

            hr = m_pStream->Seek(li, STREAM_SEEK_SET, NULL);

            if (FAILED(hr))
            {
                Trace(1, "ERROR: Seek (viewport): Seeking the viewport's stream failed.\n");
                return (DMUS_E_BADWAVE);
            }

            // Since we're restarting, re-initialize.
            m_fdwOptions &= (~DSOUND_WVP_CONVERTMASK);
            m_fdwOptions |= DSOUND_WVP_CONVERTSTATE_01;

            m_ash.cbSrcLength     = (DWORD)m_ash.dwSrcUser;
            m_ash.cbSrcLengthUsed = m_ash.cbSrcLength;

            m_ash.dwDstUser       = 0L;
            m_ash.cbDstLengthUsed = 0L;

        }
    }

    TraceI(5, "Seek (Viewport): Succeeded.\n");
    return S_OK;
}

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;
    }

    return E_FAIL;
}   

HRESULT CWaveViewPort::acmRead
(
    void
)
{
    DWORD       cbSize;
    DWORD       dwOffset;
    DWORD       fdwConvert = 0;
    MMRESULT    mmr;
    HRESULT     hr;

    V_INAME(CWaveViewPort::acmRead);
    
    for (m_ash.cbDstLengthUsed = 0; 0 == m_ash.cbDstLengthUsed; )
    {
        //  Did we use up the entire buffer?

        if (m_ash.cbSrcLengthUsed == m_ash.cbSrcLength)
        {
            //  Yep!

            dwOffset = 0L;
            cbSize   = (DWORD)m_ash.dwSrcUser;
        }
        else
        {
            //  Nope!

            dwOffset = m_ash.cbSrcLength - m_ash.cbSrcLengthUsed;
            cbSize   = (DWORD)m_ash.dwSrcUser - dwOffset;

            //  Moving the remaining data from the end of buffer to the beginning

            MoveMemory(
                    m_ash.pbSrc,                            //  Base address
                    &(m_ash.pbSrc[m_ash.cbSrcLengthUsed]),  //  Address of unused bytes
                    dwOffset);                              //  Number of unused bytes
        }

        //  Are we at the end of the stream?
        cbSize = min(cbSize, m_cbStream - m_dwOffset);

        if (0 == cbSize)
        {
            if (dwOffset)
            {
                m_ash.cbSrcLength = dwOffset;
            }
        }
        else
        {
            hr = m_pStream->Read(&(m_ash.pbSrc[dwOffset]), cbSize, &cbSize);

            if (FAILED(hr))
            {
                Trace(1, "ERROR: Read (Viewport): Attempt to read source stream returned 0x%08lx\n", hr);
                //>>>>>>>>>>>>>>>>>>>> 
                m_fdwOptions &= (~DSOUND_WVP_CONVERTMASK);
                m_fdwOptions |= DSOUND_WVP_STREAMEND;
                return(DMUS_E_CANNOTREAD);
                //>>>>>>>>>>>>>>>>>>>> 
            }

            m_dwOffset        += cbSize;
            m_ash.cbSrcLength  = cbSize + dwOffset;
        }

        switch (m_fdwOptions & DSOUND_WVP_CONVERTMASK)
        {
            case DSOUND_WVP_CONVERTSTATE_01:
                fdwConvert = ACM_STREAMCONVERTF_BLOCKALIGN;
                break;

            case DSOUND_WVP_CONVERTSTATE_02:
                fdwConvert = ACM_STREAMCONVERTF_BLOCKALIGN | ACM_STREAMCONVERTF_END;
                break;

            case DSOUND_WVP_CONVERTSTATE_03:
                fdwConvert = ACM_STREAMCONVERTF_END;
                break;

            default:
                TraceI(3, "CWaveViewPort::acmRead: Default case?!\n");
                break;
        }

        mmr = acmStreamConvert(m_hStream, &m_ash, fdwConvert);

        if (MMSYSERR_NOERROR != mmr)
        {
            Trace(1, "ERROR: Read (Viewport): Attempt to convert wave to PCM failed.\n");
            return (MMRESULTToHRESULT(mmr));
        }

        if (0 != m_ash.cbDstLengthUsed)
        {
            m_ash.dwDstUser = 0L;
            return (S_OK);
        }

        //  No data returned?

        switch (m_fdwOptions & DSOUND_WVP_CONVERTMASK)
        {
            case DSOUND_WVP_CONVERTSTATE_01:
                if (0 == cbSize)
                {
                    //  We're at the end of the stream..

                    m_fdwOptions &= (~DSOUND_WVP_CONVERTMASK);
                    m_fdwOptions |= DSOUND_WVP_CONVERTSTATE_02;
                    TraceI(5, "CWaveViewPort::acmRead: Moving to stage 2\n");
                }

                //  Otherwise, continue converting data as normal.
                break;

            case DSOUND_WVP_CONVERTSTATE_02:
                //  We have hit the last partial block!

                m_fdwOptions &= (~DSOUND_WVP_CONVERTMASK);
                m_fdwOptions |= DSOUND_WVP_CONVERTSTATE_03;
                TraceI(5, "CWaveViewPort::acmRead: Moving to stage 3\n");
                break;

            case DSOUND_WVP_CONVERTSTATE_03:
                //  No more data after end flag, NO MORE DATA!!
                m_fdwOptions &= (~DSOUND_WVP_CONVERTMASK);
                m_fdwOptions |= DSOUND_WVP_STREAMEND;
                Trace(2, "WARNING: Read (Viewport): End of source stream.\n");
                return (DMUS_E_BADWAVE);

            default:
                TraceI(3, "CWaveViewPort::acmRead: Default case?!\n");
                break;
        }
    }

    TraceI(3, "CWaveViewPort::acmRead: We should never get here!\n");

    return (S_OK);
}

//////////////////////////////////////////////////////////////////////////////
//
// ppvBuffer[] contains cpvBuffer pointers-to-samples, each to be filled with
// *pcb bytes of data. On output *pcb will contain the number of bytes (per
// buffer) actually read.
//
// pdwBusIds and pdwFuncIds are used to specify the bus and functionality
// of each buffer, but these are ignored by the wave object.
//
STDMETHODIMP CWaveViewPort::Read
(
    LPVOID         *ppvBuffer,
    LPDWORD         pdwBusIds,
    LPDWORD         pdwFuncIds,
    LPLONG          plPitchShifts,
    DWORD           cpvBuffer,
    ULONGLONG      *pcb
)
{
    HRESULT     hr = S_OK;
    DWORD       cbRead;
    DWORD       dwOffset;
    DWORD       cbSize;

    V_INAME(CWaveViewPort::Read);
    V_BUFPTR_READ(ppvBuffer, (cpvBuffer * sizeof(LPVOID)));
    V_BUFPTR_READ_OPT(pdwBusIds, (cpvBuffer * sizeof(LPDWORD)));
    V_BUFPTR_READ_OPT(pdwFuncIds, (cpvBuffer * sizeof(LPDWORD)));

    for (cbRead = cpvBuffer, cbSize = (DWORD)*pcb; cbRead; cbRead--)
    {
        V_BUFPTR_WRITE(ppvBuffer[cbRead - 1], cbSize);
    }

    if (m_fdwOptions & DSOUND_WVP_STREAMEND)
    {
        *pcb = 0;
        Trace(2, "WARNING: Read (Viewport): Attempt to read at end of stream.\n");
        return (S_FALSE);
    }

    LPVOID *ppvWriteBuffers  = ppvBuffer;
    DWORD dwWriteBufferCount = cpvBuffer;

    if (m_fdwOptions & DSOUND_WVP_NOCONVERT)
    {
        //  Total number of bytes to read... size of each buffer * number of buffers

        cbRead   = ((DWORD)*pcb) * dwWriteBufferCount;
        dwOffset = 0;

        TraceI(5, "CWaveViewPort::Read - No conversion [%d bytes]\n", cbRead);

        do
        {
            //  Calculate read size...  It's going to be the size of:
            //    1.  Remaining bytes to read.
            //    2.  Size of the buffer.
            //    3.  Remaining bytes in the stream.
            //  Whichever happens to be the smallest.

            cbSize = min(cbRead, m_ash.cbDstLength);
            cbSize = min(cbSize, m_cbStream - m_dwOffset);

            TraceI(5, "CWaveViewPort::Read - Trying to read %d bytes\n", cbSize);

            DWORD _cbSize = cbSize; cbSize = 0; // Read may not set cbSize to zero 
        
            hr = m_pStream->Read(m_ash.pbDst, _cbSize, &cbSize);

            TraceI(5, "CWaveViewPort::Read - Read %d bytes\n", cbSize);

            if (FAILED(hr))
            {
                Trace(2, "WARNING: Read (Viewport): Attempt to read returned 0x%08lx.\n", hr);
                break;
            }

            dwOffset = DeinterleaveBuffers(
                            m_pwfxTarget,
                            m_ash.pbDst,
                            (LPBYTE *)ppvWriteBuffers,
                            dwWriteBufferCount,
                            cbSize,
                            dwOffset);

            cbRead     -= cbSize;
            m_dwOffset += cbSize;

            if (m_dwOffset >= m_cbStream)
            {
                m_fdwOptions |= DSOUND_WVP_STREAMEND;
                break;
            }
        }
        while (0 != cbRead);

        if (SUCCEEDED(hr))
        {
            *pcb = dwOffset;
        }
    }
    else
    {
        // If this is the read for the precache then we should remember the fileposition, 
        // start sample for the decompressed block and the last sample passed back so we 
        // can accurately pick up from there when refilling buffers
        // We use the LPLONG plPitchShifts in the read method as a boolean
        // this is a HACK!! We need to change this...
        // *plPitchShifts == 2 is to remember the precache offset
        // *plPitchShifts == 1 is to read from there
        bool fRememberPreCache = false;
        if(plPitchShifts != NULL && *plPitchShifts == 2 && (m_fdwOptions & DSOUND_WAVEF_ONESHOT) == 0)
        {
            fRememberPreCache = true;
        }

        bool bRemoveSilence = false;
        
        cbRead   = ((DWORD)*pcb) * dwWriteBufferCount;
        dwOffset = 0;

        TraceI(5, "CWaveViewPort::Read - Conversion needed\n");

        do
        {
            if(m_dwDecompressedStart > 0 && m_dwOffset <= m_dwDecompStartOffset)
            {
                bRemoveSilence = true;
            }

            //  Is there any remnant data in destination buffer?
            if (m_ash.dwDstUser >= m_ash.cbDstLengthUsed)
            {
                if(fRememberPreCache)
                {
                    // Go back on block
                    m_dwPreCacheFilePos = m_dwOffset - m_ash.cbSrcLength;
                    m_dwFirstPCMSample = dwOffset * dwWriteBufferCount;
                }

                if(plPitchShifts != NULL && *plPitchShifts == 1)
                {
                    // Seek to the right place first
                    Seek(m_dwPCMSampleOut);

                    // Read one block since we're starting one block behind
                    hr = acmRead();
                    if(FAILED(hr))
                    {
                        break;
                    }
                }

                hr = acmRead();
            }

            if (FAILED(hr))
            {
                // acmRead spews when it fails; no need to do it again here
                break;
            }

            DWORD dwDstOffset = (ULONG)m_ash.dwDstUser;

            if(bRemoveSilence)
            {
                // We have partial data to throw away
                if(m_dwDecompStartOffset <= m_dwOffset)
                {
                    if(dwDstOffset > 0)
                    {
                        dwDstOffset += m_dwDecompStartDelta;
                    }
                    else
                    {
                        // This is the first decompressed block so we go straight to the value we know
                        dwDstOffset += m_dwDecompStartOffsetPCM;
                    }

                    m_ash.dwDstUser = dwDstOffset;
                    bRemoveSilence = false;
                }
                else
                {
                    // This is all throw away data
                    bRemoveSilence = false;
                    cbSize = min(cbRead, m_ash.cbDstLengthUsed - dwDstOffset);
                    m_ash.dwDstUser += cbSize;
                    continue;
                }
            }


            // We use the LPLONG plPitchShifts in the read method as a boolean
            // this is a HACK!! We need to change this...
            if(plPitchShifts && *plPitchShifts == 1)
            {
                dwDstOffset = m_dwPCMSampleOut - m_dwFirstPCMSample;
                m_ash.dwDstUser = dwDstOffset;
                plPitchShifts = 0;
            }

            cbSize = min(cbRead, m_ash.cbDstLengthUsed - dwDstOffset);

            dwOffset = DeinterleaveBuffers(
                            m_pwfxTarget,
                            &(m_ash.pbDst[dwDstOffset]),
                            (LPBYTE *)ppvWriteBuffers,
                            dwWriteBufferCount,
                            cbSize,
                            dwOffset);

            cbRead -= cbSize;
            m_ash.dwDstUser += cbSize;

            if ((m_fdwOptions & DSOUND_WVP_STREAMEND) &&
                (m_ash.dwDstUser >= m_ash.cbDstLengthUsed))
            {
                break;
            }
        }
        while(0 != cbRead);

        if(fRememberPreCache)
        {
            m_dwPCMSampleOut = dwOffset * dwWriteBufferCount;
        }

        if (SUCCEEDED(hr))
        {
            *pcb = dwOffset;
        }
    }

    TraceI(5, "CWaveViewPort::Read returning %x (%d bytes)\n", hr, dwOffset);
    return hr;
}

STDMETHODIMP CWaveViewPort::GetSize
(
    ULONGLONG      *pcb
)
{
    V_INAME(CWaveViewPort::GetSize);
    V_PTR_WRITE(pcb, ULONGLONG);
    
    TraceI(5, "CWaveViewPort::GetSize [%d samples]\n", m_cSamples);
    HRESULT hr = S_OK;

    if (m_fdwOptions & DSOUND_WVP_NOCONVERT)
    {
        //  No conversion.  This is trivial

        *pcb = (SAMPLE_TIME)(m_cbStream);
    }
    else if (!m_pwfxTarget)
    {
        hr = DSERR_UNINITIALIZED;
    }
    else
    {
        //  Conversion required; let's hope target format is PCM

        if (WAVE_FORMAT_PCM == m_pwfxTarget->wFormatTag)
        {
            //  Cool.  This is simply the number of samples X the block align

            *pcb = (SAMPLE_TIME)((m_cSamples - m_dwDecompressedStart) * m_pwfxTarget->nBlockAlign);
        }
        else
        {
            Trace(1, "ERROR: GetSize (Viewport): Conversion required and target is not PCM.\n");
            hr = DSERR_BADFORMAT;
        }
    }

    return (hr);
}

HRESULT CWaveViewPort::Create
(
    PCREATEVIEWPORT     pCreate
)
{
    DWORD           cbSize;
    MMRESULT        mmr;
    HRESULT         hr;
    LARGE_INTEGER   li;
    LPWAVEFORMATEX  pwfxSrc = pCreate->pwfxSource;
    LPWAVEFORMATEX  pwfxDst = pCreate->pwfxTarget;

    V_INAME(CWaveViewPort::Create);
    
    TraceI(5, "CWaveViewPort::Create [%d samples]\n", pCreate->cSamples);

    EnterCriticalSection(&m_CriticalSection);

    //  Clone source stream...

    hr = pCreate->pStream->Clone(&m_pStream);

    if (FAILED(hr))
    {
        LeaveCriticalSection(&m_CriticalSection);
        return (hr);
    }

    //  Misc assignments
    m_cSamples   = pCreate->cSamples;
    m_cbStream   = pCreate->cbStream;
    m_dwOffset   = 0L;
    m_fdwOptions = pCreate->fdwOptions;
    m_dwDecompressedStart = pCreate->dwDecompressedStart;
    m_dwDecompStartOffset = 0L;
    m_dwDecompStartOffsetPCM = 0L;
    m_dwDecompStartDelta = 0L;

    TraceI(5, "CWaveViewPort:: %d samples\n", m_cSamples);

    //  Allocate destination format
    cbSize = SIZEOFFORMATEX(pwfxDst);

    m_pwfxTarget = (LPWAVEFORMATEX)GlobalAllocPtr(GHND, cbSize);

    if (NULL == m_pwfxTarget)
    {
        LeaveCriticalSection(&m_CriticalSection);
        TraceI(1, "OUT OF MEMORY: CWaveViewPort::Create - size: %d \n", cbSize);
        return (E_OUTOFMEMORY);
    }

    //  We don't own the buffer for pwfxDst, so we can't touch its cbSize.
    //  We have to set the size manually on PCM, we KNOW the buffer is
    //  large enough.

    CopyFormat(m_pwfxTarget, pwfxDst);
    if (WAVE_FORMAT_PCM == m_pwfxTarget->wFormatTag)
    {
        m_pwfxTarget->cbSize = 0;
    }

    //  Calculating (block-aligned) size of destination buffer...
    cbSize = (pwfxDst->nAvgBytesPerSec * CONVERTLENGTH) / 1000;
    cbSize = BLOCKALIGN(cbSize, pwfxDst->nBlockAlign);

    m_ash.pbDst = (LPBYTE)GlobalAllocPtr(GHND, cbSize);

    if (NULL == m_ash.pbDst)
    {
        LeaveCriticalSection(&m_CriticalSection);
        TraceI(1, "OUT OF MEMORY: CWaveViewPort::Create 01\n");
        return (E_OUTOFMEMORY);
    }

    m_ash.cbDstLength = cbSize;

    //  Getting stream starting offset...

    li.HighPart = 0;
    li.LowPart  = 0;
    hr = m_pStream->Seek(li, STREAM_SEEK_CUR, (ULARGE_INTEGER *)(&li));

    m_dwStartPos = li.LowPart;

    //  Do we need to use the ACM?
    if (FormatCmp(pwfxSrc, pwfxDst))
    {
        //  Formats compare!!  All we need to do is to copy the data straight
        //  from the source stream.  Way Cool!!

        TraceI(5, "Source and Destination formats are similar!\n");

        m_fdwOptions |= DSOUND_WVP_NOCONVERT;
    }
    else
    {
        //  Source and destination formats are different...

        TraceI(5, "CWaveViewPort:Create: Formats are different... Use ACM!\n");

        m_fdwOptions |= DSOUND_WVP_CONVERTSTATE_01;

        mmr = acmStreamOpen(&m_hStream, NULL, pwfxSrc, pwfxDst, NULL, 0, 0, 0);

        if (MMSYSERR_NOERROR != mmr)
        {
            Trace(1, "ERROR: Create (Viewport): Attempt to open a conversion stream failed.\n");
            LeaveCriticalSection(&m_CriticalSection);
            return MMRESULTToHRESULT(mmr);
        }

        mmr = acmStreamSize(m_hStream, cbSize, &cbSize, ACM_STREAMSIZEF_DESTINATION);

        if (MMSYSERR_NOERROR != mmr)
        {
            Trace(1, "ERROR: Create(Viewport): Could not convert target stream size to source format.\n");
            LeaveCriticalSection(&m_CriticalSection);
            return MMRESULTToHRESULT(mmr);
        }

        m_ash.cbSrcLength = cbSize;
        m_ash.pbSrc       = (LPBYTE)GlobalAllocPtr(GHND, cbSize);

        if (NULL == m_ash.pbSrc)
        {
            TraceI(1, "OUT OF MEMORY: CWaveViewPort:Create: GlobalAlloc failed.\n");
            LeaveCriticalSection(&m_CriticalSection);
            return E_OUTOFMEMORY;
        }

        // Also get the position for the actual start for the decompressed data
        if(m_dwDecompressedStart > 0)
        {
            m_dwDecompStartOffsetPCM = m_dwDecompressedStart * (pwfxDst->wBitsPerSample / 8) * pwfxDst->nChannels;
            mmr = acmStreamSize(m_hStream, m_dwDecompStartOffsetPCM, &m_dwDecompStartOffset, ACM_STREAMSIZEF_DESTINATION);
            
            DWORD dwDelta = 0;
            mmr = acmStreamSize(m_hStream, m_dwDecompStartOffset, &dwDelta, ACM_STREAMSIZEF_SOURCE);

            m_dwDecompStartDelta = m_dwDecompStartOffsetPCM - dwDelta;
            m_dwDecompStartOffset += m_dwStartPos;
        }

        //  For the source buffer, it is the full buffer size.
        m_ash.dwSrcUser       = m_ash.cbSrcLength;
        m_ash.cbSrcLengthUsed = m_ash.cbSrcLength;

        //  For the destination buffer, it is the offset into the buffer
        //  where the data can be found.
        m_ash.dwDstUser       = 0L;
        m_ash.cbDstLengthUsed = 0L;

        m_ash.cbStruct = sizeof(ACMSTREAMHEADER);

        mmr= acmStreamPrepareHeader(m_hStream, &m_ash, 0L);

        if (MMSYSERR_NOERROR != mmr)
        {
            Trace(1, "ERROR: Create (Viewport): Attempt to prepare header for conversion stream failed.\n");
            LeaveCriticalSection(&m_CriticalSection);
            return MMRESULTToHRESULT(mmr);
        }
    }

    LeaveCriticalSection(&m_CriticalSection);
    return S_OK;
}