/*
* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:    RTP Datasink
*
*/




// INCLUDE FILES
#include <mmf/common/mmfcontroller.h> 
#include "rtpheader.h"
#include "mccrtpdatasink.h"
#include "mmccevents.h"
#include "mccinternaldef.h"
#include "mccrtpdefs.h"
#include "mmccinterfacedef.h"

// MACROS

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS
#define MCC_RTPSINK_ENDPOINT_ID MCC_ENDPOINT_ID( static_cast<MDataSink*>( this ) )

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CMccRtpDataSink::CMccRtpDataSink
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CMccRtpDataSink::CMccRtpDataSink() :
    CMccDataSink( KMccRtpSinkUid ),
    MMccRtpInterface(), iRtpStreamId( KNullId )
    {
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::NewSinkL
// Static constructor.
// -----------------------------------------------------------------------------
//
MDataSink* CMccRtpDataSink::NewSinkL( TUid /*aImplementationUid*/, 
                                      const TDesC8& /*aInitData*/ )
    {
    TRACE_RTP_SINK_PRINT( "CMccRtpDataSink::NewSinkL()" )
       
    CMccRtpDataSink* self = new ( ELeave ) CMccRtpDataSink();
    return static_cast<MDataSink*>( self ); 
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::ConstructSinkL
// class MDataSink inherited 2nd phase construction
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::ConstructSinkL( const TDesC8& /*aInitData*/ )
    {
    TRACE_RTP_SINK_PRINT( "CMccRtpDataSink::ConstructSinkL" )
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::~CMccRtpDataSink
// Destructor
// -----------------------------------------------------------------------------
//
CMccRtpDataSink::~CMccRtpDataSink()
    {
    TRACE_RTP_SINK_PRINT2( "CMccRtpDataSink::~CMccRtpDataSink 0x%x", this )
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::SetCurrentUser
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::Mute( TBool aMuteOn, TUint8 aExceptionPt )
    {
    TRACE_RTP_SINK_PRINT3( "CMccRtpDataSink::Mute, STATE: %d, PT: %u", 
        aMuteOn, aExceptionPt )
    
    iMuteOn = aMuteOn;
    iExceptionPt = aExceptionPt;
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::SetCurrentUser
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::SetCurrentUser( MAsyncEventHandler* /*aEventHandler*/ )
    {
//    iEventHandler = aEventHandler;
    }
    
// -----------------------------------------------------------------------------
// CMccRtpDataSink::SinkThreadLogon
//
// Method to 'logon' the data sink to the same thread that sink will be consuming
// data in. Thread specific initialisation is done here.
// -----------------------------------------------------------------------------
//
TInt CMccRtpDataSink::SinkThreadLogon( MAsyncEventHandler& /*aEventHandler*/ ) 
    {
    TRACE_RTP_SINK_PRINT ( "CMccRtpDataSink::SinkThreadLogon" )
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::SinkThreadLogoff
//
// Method to 'logoff' the data sink from the same thread that sink consumes 
// data in. Thread specific releasing of resources is done here.
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::SinkThreadLogoff() 
    {
    TRACE_RTP_SINK_PRINT( "CMccRtpDataSink::SinkThreadLogoff" )
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::SetSinkDataTypeCode
// Sets the datatype code ( codec )
// ----------------------------------------------------------------------------- 
//
TInt CMccRtpDataSink::SetSinkDataTypeCode( TFourCC /*aCodec*/, TMediaId /*aMedia*/ )
    {
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::SinkDataTypeCode
// Returns the datatype code ( codec )
// -----------------------------------------------------------------------------
//
TFourCC CMccRtpDataSink::SinkDataTypeCode( TMediaId aMediaId )
    {
    if ( KUidMediaTypeAudio == aMediaId.iMediaType )
        {
        return iCodecInfo.iFourCC;
        }
    else
        {
        // Initializes to KMMFFourCCCodeNULL so the caller cannot see
        // if this sink really has some media type currently registered
        return TFourCC();
        }
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::EmptyBufferL
// NOT SUPPORTED. MDataSink pure virtual function must be implemented.
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::EmptyBufferL( CMMFBuffer* /*aBuffer*/, 
                                    MDataSource* /*aSupplier*/, 
                                    TMediaId /*aMediaId*/ )
    {
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::EmptyBufferL
// Overload to class MDataSink pure virtual function implementation.
// Take RTP packet in the buffer and send it.
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::EmptyBufferL( CMMFBuffer* aBuffer,
                                    MDataSource* aSupplier,
                                    TMediaId /*aMediaId*/,
                                    TRtpSendHeader& /*aHeaderInfo*/ )
    {
    __ASSERT_ALWAYS( aBuffer, User::Leave( KErrArgument ) );
    __ASSERT_ALWAYS( aSupplier, User::Leave( KErrArgument ) );
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::BufferFilledL
// NOT SUPPORTED. MDataSink pure virtual function must be implemented.
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::BufferFilledL( CMMFBuffer* /*aBuffer*/ )
    {
    User::Leave( KErrNotSupported );
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::CanCreateSinkBuffer
// NOT SUPPORTED. MDataSink pure virtual function must be implemented.
// -----------------------------------------------------------------------------
//
TBool CMccRtpDataSink::CanCreateSinkBuffer()
    {
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::CreateSinkBufferL
// NOT SUPPORTED. MDataSink pure virtual function must be implemented.
// -----------------------------------------------------------------------------
//
CMMFBuffer* CMccRtpDataSink::CreateSinkBufferL( TMediaId /*aMediaId*/,
                                                TBool& /*aReference*/ )
    {
    User::Leave( KErrNotSupported ); 
    return NULL;
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::SinkPrimeL
// Prime the sink. 
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::SinkPrimeL()
    { 
    TRACE_RTP_SINK_PRINT( "CMccRtpDataSink::SinkPrimeL" )
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::SinkPlayL
// Start the playout operation.
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::SinkPlayL()
    {
    TRACE_RTP_SINK_PRINT( "CMccRtpDataSink::SinkPlayL IN" )
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::SinkPauseL
// Pauses the playout operation.
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::SinkPauseL()
    {
    TRACE_RTP_SINK_PRINT( "CMccRtpDataSink::SinkPauseL" )
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::SinkStopL
// Stop the playout operation. 
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::SinkStopL()
    {
    TRACE_RTP_SINK_PRINT( "CMccRtpDataSink::SinkStopL" )
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::SendMediaSignallingL()
// Sends media level signalling
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::SendMediaSignallingL( const TMccEvent& /*aEvent*/ )
    {
    TRACE_RTP_SINK_PRINT( "CMccRtpDataSink::SendMediaSignallingL" )
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::DoCreateStreamL
// Creates a transmit stream.
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::DoCreateStreamL()
    {
    TRACE_RTP_SINK_PRINT( "CMccRtpDataSink::DoCreateStreamL" )
    
    iRtpStreamId = 1;
    }


// ---------------------------------------------------------------------------
// CMccRtpDataSink::SinkCustomCommand()
// 
// ---------------------------------------------------------------------------
//
void CMccRtpDataSink::SinkCustomCommand( TMMFMessage& /*aMessage*/ )
    {
    TRACE_RTP_SINK_PRINT( "CMccRtpDataSink::SinkCustomCommand" )
    }

// ---------------------------------------------------------------------------
// CMccRtpDataSink::SendRTCPData()
// Sends Non-RTCP data
// ---------------------------------------------------------------------------
//    
void CMccRtpDataSink::SendRTCPDataL( const TDesC8& /*aData*/ )
    {
    }
    
// -----------------------------------------------------------------------------
// CMccRtpDataSink::HandleBySsrc
// -----------------------------------------------------------------------------
//   
TBool CMccRtpDataSink::HandleBySsrc( const TRtpSSRC& /*aSsrc*/ )
    {
    return ETrue;
    }
    
// -----------------------------------------------------------------------------
// CMccRtpDataSink::RtpStreamId
// -----------------------------------------------------------------------------
//    
TRtpId CMccRtpDataSink::RtpStreamId()
    {
    return iRtpStreamId;
    }
    
// -----------------------------------------------------------------------------
// CMccRtpDataSink::DoCreateSrtpStreamL
// -----------------------------------------------------------------------------
// 
void CMccRtpDataSink::DoCreateSrtpStreamL()
    {
    }
    
// -----------------------------------------------------------------------------
// CMccRtpDataSink::IsSink
// -----------------------------------------------------------------------------
//
TBool CMccRtpDataSink::IsSink() const
    {
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::IsSending
// -----------------------------------------------------------------------------
//        
TBool CMccRtpDataSink::IsSending() const
    {
    return ETrue;
    }
    
// -----------------------------------------------------------------------------
// CMccRtpDataSink::AddUserL
// -----------------------------------------------------------------------------
//
void CMccRtpDataSink::AddUserL( TUint32 /*aStreamId*/ )
    {
    
    }

// -----------------------------------------------------------------------------
// CMccRtpDataSink::SendStreamEventToClient()
// -----------------------------------------------------------------------------
//	
void CMccRtpDataSink::SendStreamEventToClient( 
    TMccEventType /*aEventType*/,
    TInt /*aError*/ )
    {
    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSink::SendStreamEventToClient" )
    }
    
// ---------------------------------------------------------------------------
// CMccRtpDataSink::SetMediaClock
// ---------------------------------------------------------------------------
//    
void CMccRtpDataSink::SetMediaClock( CMccRtpMediaClock& /*aRtpMediaClock*/ )
    {
    TRACE_RTP_SINK_PRINT( "CMccRtpDataSink::SetMediaClock" )
    
    //iRtpMediaClock = &aRtpMediaClock;   
    }    
    
// ---------------------------------------------------------------------------
// FROM SRTP API
// This function is called by SRTP Stream initiated with 
// MSRTPReKeyingObserver when a master key is stale and needs 
// to be refreshed.  
// ---------------------------------------------------------------------------
//
void CMccRtpDataSink::SRTPMasterKeyStaleEvent( const CSRTPStream& /*aStream*/ )
    {
    }

// ---------------------------------------------------------------------------
// FROM SRTP API
// This function is called by SRTP Stream initiated with 
// CSRTPSession  when a master key is stale and
// needs to be refreshed.  
// ---------------------------------------------------------------------------
void CMccRtpDataSink::SRTPMasterKeyStaleEvent(const CSRTPSession& /*aSession*/ )
    {
    } 
    
// ========================== OTHER EXPORTED FUNCTIONS =========================

//  End of File