/*++

Copyright (c) 1998-1999  Microsoft Corporation

Module Name:

    wavecall.cpp 

Abstract:

    This module contains implementation of CWaveMSPCall.

Author:
    
    Zoltan Szilagyi (zoltans)   September 7, 1998

--*/

#include "stdafx.h"

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//

CWaveMSPCall::CWaveMSPCall() : CMSPCallMultiGraph()
{
    LOG((MSP_TRACE, "CWaveMSPCall::CWaveMSPCall entered."));

    m_fHavePerAddressWaveIDs = FALSE;
    m_dwPerAddressWaveInID   = 0xfeedface;
    m_dwPerAddressWaveOutID  = 0xfeedface;
    
    LOG((MSP_TRACE, "CWaveMSPCall::CWaveMSPCall exited."));
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//

CWaveMSPCall::~CWaveMSPCall()
{
    LOG((MSP_TRACE, "CWaveMSPCall::~CWaveMSPCall entered."));
    LOG((MSP_TRACE, "CWaveMSPCall::~CWaveMSPCall exited."));
}

ULONG CWaveMSPCall::MSPCallAddRef(void)
{
    return MSPAddRefHelper(this);
}

ULONG CWaveMSPCall::MSPCallRelease(void)
{
    return MSPReleaseHelper(this);
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//

HRESULT CWaveMSPCall::Init(
    IN      CMSPAddress *       pMSPAddress,
    IN      MSP_HANDLE          htCall,
    IN      DWORD               dwReserved,
    IN      DWORD               dwMediaType
    )
{
    // No need to acquire locks on this call because it is called only
    // once when the object is created. No other calls can be made on
    // this object at this point.

    LOG((MSP_TRACE, "CWaveMSPCall::Init - enter"));
    
    //
    // First do the base class method. We are adding to the functionality,
    // not replacing it.
    //

    HRESULT hr;

    hr = CMSPCallMultiGraph::Init(pMSPAddress,
                                  htCall,
                                  dwReserved,
                                  dwMediaType);

    if (FAILED(hr))
    {
        LOG((MSP_ERROR, "CWaveMSPCall::Init - "
            "base class method failed: %x", hr));

        return hr;
    }

    //
    // Our calls always come with two streams. Create them now. Use the base class
    // methods, as our overriden methods (exposed to the user) purposely fail in order
    // to keep the user from creating or removing streams themselves.
    // These methods return a pointer to the ITStream. They get saved in our list of
    // ITStreams, and we also save them here as CWaveMSPStream pointers.
    //

    ITStream * pStream;

    //
    // Create the capture stream.
    //

    hr = InternalCreateStream (dwMediaType,
                               TD_CAPTURE,
                               &pStream);

    if (FAILED(hr))
    {
        LOG((MSP_ERROR, "CWaveMSPCall::Init - "
            "couldn't create capture stream: %x", hr));

        return hr;
    }

    m_pCaptureStream = dynamic_cast<CWaveMSPStream *> (pStream);

    if ( m_pCaptureStream == NULL )
    {
        LOG((MSP_ERROR, "CWaveMSPCall::Init - "
            "couldn't dynamic_cast capture stream - exit E_FAIL"));

        return E_FAIL;
    }

    pStream->Release();
 
    //
    // Create the render stream.
    //

    hr = InternalCreateStream (dwMediaType,
                               TD_RENDER,
                               &pStream);

    if (FAILED(hr))
    {
        LOG((MSP_ERROR, "CWaveMSPCall::Init - "
            "couldn't create capture stream: %x", hr));

        return hr;
    }

    m_pRenderStream = dynamic_cast<CWaveMSPStream *> (pStream);

    if ( m_pRenderStream == NULL )
    {
        LOG((MSP_ERROR, "CWaveMSPCall::Init - "
            "couldn't dynamic_cast render stream - exit E_FAIL"));

        return E_FAIL;
    }

    pStream->Release();

    LOG((MSP_TRACE, "CWaveMSPCall::Init - exit S_OK"));

    return S_OK;
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// Public method called by the address to tell us the per-address wave IDs. We
// hold on to them until we know whether we have per-call waveids, and if we
// don't, then we set them on the streams.
//
//

HRESULT CWaveMSPCall::SetWaveIDs(
    IN      DWORD               dwWaveInID,
    IN      DWORD               dwWaveOutID
    )
{
    LOG((MSP_TRACE, "CWaveMSPCall::SetWaveIDs - enter"));

    m_fHavePerAddressWaveIDs = TRUE;
    m_dwPerAddressWaveInID   = dwWaveInID;
    m_dwPerAddressWaveOutID  = dwWaveOutID;

    LOG((MSP_TRACE, "CWaveMSPCall::SetWaveIDs - exit S_OK"));

    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// We override this to make sure the number of
// streams we have is constant.
//

STDMETHODIMP CWaveMSPCall::CreateStream (
    IN      long                lMediaType,
    IN      TERMINAL_DIRECTION  Direction,
    IN OUT  ITStream **         ppStream
    )
{
    LOG((MSP_TRACE, "CWaveMSPCall::CreateStream entered."));
    LOG((MSP_TRACE, "CWaveMSPCall::CreateStream - "
        "we have a fixed set of streams - exit TAPI_E_MAXSTREAMS"));

    return TAPI_E_MAXSTREAMS;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// We override this to make sure the number of
// streams we have is constant.
//

STDMETHODIMP CWaveMSPCall::RemoveStream (
    IN      ITStream *          pStream
    )
{
    LOG((MSP_TRACE, "CWaveMSPCall::RemoveStream entered."));
    LOG((MSP_TRACE, "CWaveMSPCall::RemoveStream - "
        "we have a fixed set of streams - exit TAPI_E_NOTSUPPORTED"));

    return TAPI_E_NOTSUPPORTED;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// This is our override to create the right kind of stream on stream creation.
// The base class checks the arguments for us.
//

HRESULT CWaveMSPCall::CreateStreamObject(
        IN      DWORD               dwMediaType,
        IN      TERMINAL_DIRECTION  Direction,
        IN      IMediaEvent *       pGraph,
        IN      ITStream **         ppStream
        )
{
    LOG((MSP_TRACE, "CWaveMSPCall::CreateStreamObject - enter"));

    HRESULT hr;
    CMSPComObject<CWaveMSPStream> * pStream;
 
    hr = CMSPComObject<CWaveMSPStream>::CreateInstance( &pStream );

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CWaveMSPCall::CreateStreamObject - "
            "can't create stream object - 0x%08x", hr));

        return hr;
    }

    hr = pStream->_InternalQueryInterface( IID_ITStream,
                                           (void **) ppStream );

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CWaveMSPCall::CreateStreamObject - "
            "can't get ITStream interface - 0x%08x", hr));

        delete pStream;
        return hr;
    }

    hr = pStream->Init( (MSP_HANDLE) m_pMSPAddress,
                       this,
                       pGraph,
                       dwMediaType,
                       Direction);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CWaveMSPCall::CreateStreamObject - "
            "can't Init stream object - 0x%08x", hr));

        (*ppStream)->Release();
        return hr;
    }

    LOG((MSP_TRACE, "CWaveMSPCall::CreateStreamObject - exit S_OK"));
    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// First DWORD =  Command                Second DWORD  Third DWORD
// -------------  -------                ------------  -----------
// 0              Set wave IDs           WaveIn ID     WaveOut ID
// 1              Start streaming        <ignored>     <ignored>
// 2              Stop streaming         <ignored>     <ignored>
// 3 <per-address, not per-call>
// 4 <per-address, not per-call>
// 5              Suspend streaming      <ignored>     <ignored>
// 6              Resume streaming       <ignored>     <ignored>
// 7              Wave IDs unavailable   <ignored>     <ignored>
//
// The method returns S_OK even if an individual stream failed to
// start, stop, or initialize. This is because TAPI 3.0 doesn't need to
// know about streaming failures in this code path. Instead, we
// generate events to note failures (in the stream code).
//

HRESULT CWaveMSPCall::ReceiveTSPCallData(
    IN      PBYTE               pBuffer,
    IN      DWORD               dwSize
    )
{
    LOG((MSP_TRACE, "CWaveMSPCall::ReceiveTSPCallData - enter"));

    //
    // Check that the buffer is as big as advertised.
    //

    if ( IsBadWritePtr(pBuffer, sizeof(BYTE) * dwSize) )
    {
        LOG((MSP_ERROR, "CWaveMSPCall::ReceiveTSPCallData - "
            "bad buffer - exit E_POINTER"));

        return E_POINTER;
    }

    //
    // Check if we have a command DWORD.
    //

    if ( dwSize < sizeof(DWORD) )
    {
        LOG((MSP_ERROR, "CWaveMSPCall::ReceiveTSPCallData - "
            "need a DWORD for command - exit E_INVALIDARG"));

        return E_INVALIDARG;
    }

    //
    // We are going to access the streams lists -- grab the lock
    //

    CLock lock(m_lock);

    _ASSERTE( m_Streams.GetSize() == 2 );

    int i;
    HRESULT hr;

    //
    // Based on the command, take action:
    //

    switch ( ((DWORD *) pBuffer) [0] )
    {
        //
        // Notes on waveid messages:
        //
        //    * The capture stream is the one with a capture terminal, and thus we
        //      need to give it the wave out id, and we need to give the render
        //      terminal the wave in ID.
        //    * We do not return errors or fire events on failure. If something
        //      fails, then the waveid will not be set for that stream, and
        //      a failure event will be fired when streaming begins.
        //

    case 0: // set per-call wave IDs (overrides per-address waveids)
        {
            if ( dwSize < 3 * sizeof(DWORD) )
            {
                LOG((MSP_ERROR, "CWaveMSPCall::ReceiveTSPCallData - "
                    "need 3 DWORDs for SetWaveID command - "
                    "exit E_INVALIDARG"));

                return E_INVALIDARG;
            }

            LOG((MSP_INFO, "CWaveMSPCall::ReceiveTSPCallData - "
                "setting WaveInID=%d, WaveOutID=%d",
                ((DWORD *) pBuffer) [1],
                ((DWORD *) pBuffer) [2]));

            // waveout
            hr = m_pCaptureStream->SetWaveID( ((DWORD *) pBuffer) [2] );

            if ( FAILED(hr) )
            {
                LOG((MSP_ERROR, "CWaveMSPCall::ReceiveTSPCallData - "
                    "capture stream SetWaveID (per-call) failed 0x%08x - "
                    "continuing", hr));
            }

            // wavein
            hr = m_pRenderStream ->SetWaveID( ((DWORD *) pBuffer) [1] );

            if ( FAILED(hr) )
            {
                LOG((MSP_ERROR, "CWaveMSPCall::ReceiveTSPCallData - "
                    "render stream SetWaveID (per-call) failed 0x%08x - "
                    "continuing", hr));
            }

        }
        break;


    case 7: // no per-call wave IDs (use per-address waveids if available)
        {
            if ( m_fHavePerAddressWaveIDs )
            {
                hr = m_pCaptureStream->SetWaveID( m_dwPerAddressWaveOutID );

                if ( FAILED(hr) )
                {
                    LOG((MSP_ERROR, "CWaveMSPCall::ReceiveTSPCallData - "
                        "capture stream SetWaveID (cached per-address id) "
                        "failed 0x%08x - continuing", hr));
                }

                hr = m_pRenderStream ->SetWaveID( m_dwPerAddressWaveInID );

                if ( FAILED(hr) )
                {
                    LOG((MSP_ERROR, "CWaveMSPCall::ReceiveTSPCallData - "
                        "render stream SetWaveID (cached per-address id) "
                        "failed 0x%08x - continuing", hr));
                }
            }
            else
            {
                LOG((MSP_ERROR, "CWaveMSPCall::ReceiveTSPCallData - "
                    "no per-address and no per-call wave ids - continuing"));
            }
        }
        break;


    //
    // Notes on streaming state control messages:
    //
    // It is crucial that the order of invocations here be
    // kept the same for each message that is dispatched to streams;
    // otherwise you may get a different stream resuming than had
    // originally started in the case where only one stream can
    // run at a time (half-duplex hardware). Also, the exact order
    // (capture first, render second) is important as well! We get
    // better error reporting -- synchronous instead of asynchronous
    // -- for half-duplex line devices this way.
    //

    case 1: // start streaming
        {
            hr = m_pCaptureStream ->StartStream(); // waveout
            hr = m_pRenderStream  ->StartStream(); // wavein
        }
        break;

    case 2: // stop streaming
        {
            hr = m_pCaptureStream ->StopStream(); // waveout
            hr = m_pRenderStream  ->StopStream(); // wavein
        }
        break;

    case 5: // suspend streaming
        {
            hr = m_pCaptureStream ->SuspendStream(); // waveout
            hr = m_pRenderStream  ->SuspendStream(); // wavein
        }
        break;

    case 6: // resume streaming
        {
            hr = m_pCaptureStream ->ResumeStream(); // waveout
            hr = m_pRenderStream  ->ResumeStream(); // wavein
        }
        break;

    default:
        LOG((MSP_ERROR, "CWaveMSPCall::ReceiveTSPCallData - "
            "invalid command - exit E_INVALIDARG"));

        return E_INVALIDARG;

    }

    LOG((MSP_TRACE, "CWaveMSPCall::ReceiveTSPCallData - exit S_OK"));
    return S_OK;
}

// eof