/*

* 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 Datasource

*

*/

// INCLUDE FILES

#include <in_sock.h>

#include <mmf/common/mmfcontroller.h>

#include "rtpapi.h"

#include "mccrtpdatasource.h"

#include "mccinternalevents.h"

#include "formatstatemachine.h"

#include "mccrtpdefs.h"

#include "mmccinterfacedef.h"

#include "mcctimermanager.h"

#include <srtpcryptocontext.h>

#include <srtpstreamin.h>

// MACROS

#define MCC_RTPSOURCE_ENDPOINT_ID reinterpret_cast<TUint32>( static_cast<MDataSource*>( this ) )

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

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

// -----------------------------------------------------------------------------

// CMccRtpDataSource::CMccRtpDataSource

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CMccRtpDataSource::CMccRtpDataSource() : 

    CMccDataSource( KMccRtpSourceUid ),

    MMccRtpInterface(),

    iStandByTimerValue( KRtpStandByTimer ),

    iRtpStreamId( KNullId ),

    iInactivityTimerId( KMaxTUint32 )

    {

    iCurRecvPayloadType = KMccPTNotDefined;

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::ConstructSourceL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CMccRtpDataSource::ConstructSourceL( const TDesC8& aInitData )

    {

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::ConstructSourceL" )

    SetStateL( ERtpStateConstructed );

    TMccRtpSourceSetting rtpSettings;

    rtpSettings.iStandByTimerValue = 200;

    TMccRtpSourceSettingBuf rtpSettingsBuf( rtpSettings );

    if ( aInitData.Length() > 0)

	    {

	   	TMccRtpSourceSettingBuf settingsBuf;

		settingsBuf.Copy( aInitData );

		iStandByTimerValue = settingsBuf().iStandByTimerValue;

	    }

    iTimer = CMccTimerManager::NewL();

    TRACE_RTP_SOURCE_PRINT2( "CMccRtpDataSource::ConstructSourceL iStandByTimerValue %d",

        iStandByTimerValue )

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::NewSourceL

// Static constructor.

// -----------------------------------------------------------------------------

//

MDataSource* CMccRtpDataSource::NewSourceL( TUid /*aImplementationUid*/, 

                                            const TDesC8& /*aInitData*/ )

    {

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::NewSourceL" )

    CMccRtpDataSource* self = new ( ELeave ) CMccRtpDataSource();

    return static_cast<MDataSource*>( self );

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::~CMccRtpDataSource()

// Destructor.

// -----------------------------------------------------------------------------

//

CMccRtpDataSource::~CMccRtpDataSource()

    {

    TRACE_RTP_SOURCE_PRINT2( "CMccRtpDataSource::~CMccRtpDataSource 0x%x", this )

    iBufferToFill = NULL;

    iEventHandler = NULL;

    iFillBufferRequester = NULL;

    CloseStreams();

    iUsers.Close();

    delete iTimer;

    delete iJitCalc;

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::~CMccRtpDataSource OUT" )

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::FillBufferL

// FillBufferL works synchronously.

// -----------------------------------------------------------------------------

//

void CMccRtpDataSource::FillBufferL( CMMFBuffer* aBuffer, 

                                     MDataSink*  aConsumer, 

                                     TMediaId    /*aMediaId*/ )

    {    

    TRACE_RTP_SOURCE_PRINT ( "CMccRtpDataSource::FillBufferL" )

    // Sink might want to indicate pause/stop by passing NULL buffer

    if ( aBuffer )

        {

        __ASSERT_ALWAYS ( aConsumer, User::Leave( KErrArgument ) );

        __ASSERT_ALWAYS ( KUidMmfDataBuffer == aBuffer->Type( ), 

        User::Leave( KErrNotSupported ) );

        }

    iBufferToFill = static_cast<CMMFDataBuffer*>( aBuffer );

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::CanCreateSourceBuffer

// NOT SUPPORTED. MDataSource pure virtual function must to be implemented.

// -----------------------------------------------------------------------------

//

TBool CMccRtpDataSource::CanCreateSourceBuffer()

    {

    return EFalse;

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::CreateSourceBufferL

// NOT SUPPORTED. MDataSource pure virtual function must to be implemented.

// -----------------------------------------------------------------------------

//

CMMFBuffer* CMccRtpDataSource::CreateSourceBufferL( TMediaId /*aMediaId*/,

                                                    TBool& /*aReference*/ )

    {

    TRACE_RTP_SOURCE_PRINT ( "CMccRtpDataSource::CreateSourceBufferL KErrNotSupported" )

    User::Leave( KErrNotSupported );

    return NULL;

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::RtpPacketReceived

// RTP stack callback function for received RTP packet.

// -----------------------------------------------------------------------------

//

void CMccRtpDataSource::RtpPacketReceived( TRtpId aStreamId, 

                                           const TRtpRecvHeader& aHeaderInfo, 

                                           const TDesC8& aPayloadData )

	{

    TRACE_RTP_SOURCE_PRINT2( "CMccRtpDataSource::RtpPacketReceived iSecureKeyExpired: %d",

        iSecureKeyExpired )

    TRACE_RTP_SOURCE_PRINT2( "CMccRtpDataSource::RtpPacketReceived iPayloadType: %u",

        aHeaderInfo.iPayloadType )

    // Filter out also bogus payload types here. NB; should something be done

    // for the trapped errorcode and bogus RTP packets. Though they should not

    // reach this point.

	if ( !iSecureKeyExpired &&

	     aHeaderInfo.iPayloadType < KPayloadTypeUndefined )

		{

		TRAP_IGNORE( RtpPacketReceivedL( aStreamId, aHeaderInfo, aPayloadData ) )

		}

	}

// -----------------------------------------------------------------------------

// CMccRtpDataSource::RtpPacketReceivedL

// RTP stack callback function for received RTP packet.

// -----------------------------------------------------------------------------

//

void CMccRtpDataSource::RtpPacketReceivedL( TRtpId aStreamId, 

                                           const TRtpRecvHeader& aHeaderInfo, 

                                           const TDesC8& aPayloadData )

    {

    TRACE_RTP_SOURCE_PRINT2( "CMccRtpDataSource::RtpPacketReceivedL DATALEN: %d",

        aPayloadData.Length() )

    TRACE_RTP_SOURCE_PRINT2( "CMccRtpDataSource::RtpPacketReceivedL ASTREAM: %d",

        aStreamId )

    TRACE_RTP_SOURCE_PRINT2( "CMccRtpDataSource::RtpPacketReceivedL ISTREAM: %d",

        iRtpStreamId )

    TRACE_RTP_SOURCE_PRINT2( "CMccRtpDataSource::RtpPacketReceivedL SEQ_NUM: %d",

        aHeaderInfo.iSeqNum )

    TRACE_RTP_SOURCE_PRINT2( "CMccRtpDataSource::RtpPacketReceivedL T_STAMP: %d",

        aHeaderInfo.iTimestamp )

    TRACE_RTP_SOURCE_PRINT2( "CMccRtpDataSource::RtpPacketReceivedL MARKER: %d",

        aHeaderInfo.iMarker )

    TRACE_RTP_SOURCE_PRINT2( "CMccRtpDataSource::RtpPacketReceivedL STATE: %d",

        State() )

    if ( ERtpStatePlaying == State() )

        {

        __ASSERT_ALWAYS( iBufferToFill, User::Leave( KErrNotReady ) );

        __ASSERT_ALWAYS( iFillBufferRequester, User::Leave( KErrNotReady ) );

        TMccRtpUser* currentUser = ValidatePacketL( aStreamId, aHeaderInfo, aPayloadData );

        TBool isCN = EFalse;

        // Change the main receive PT only if it is not CN.

        if ( KCnPayloadType != aHeaderInfo.iPayloadType &&

             KCnPayloadTypeReserved != aHeaderInfo.iPayloadType )

            {

            iCurRecvPayloadType = aHeaderInfo.iPayloadType;

            }

        else

            {

            isCN = ETrue;

            }

        if ( InactivityTimerActive() )

            {

            TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::resetting inactivity timer" )

            StartInactivityTimerL( iTimeoutTime );

            }

        // Note that ValidataPacketL may return a NULL ptr, thus guard against

        // it.

        if ( currentUser )

            {

  		    StartRtpStandByTimerL( currentUser );

  		    DoStandByDecision( currentUser );

            }

        // Do jitter calculations

        if ( iJitCalc->IsObserving() )

            {

            iJitCalc->RtpPacketReceived( aHeaderInfo.iTimestamp,

                                         aHeaderInfo.iMarker );

            }

        // First packet after SourcePlayL, notify event handler by sending

        // the event.

        if ( !iDlStreamStarted )

            {

            iDlStreamStarted = ETrue;

            SendInternalRtpEventToClient( iEventHandler,

                                          KMccRtpSourceUid, 

                                          KMccInternalRtpSrcMmfEvent, 

                                          KMccActivityEvent,

                                          MCC_RTPSOURCE_ENDPOINT_ID );

            }

        // CN is not currently sent forward to decoding and playback. It

        // causes problems with jitterbuffering and results into a degraded

        // audio quality.

        if ( !isCN )

            {

            TRAPD( err, PlayoutRtpPacketL( aHeaderInfo, aPayloadData ) )

            // Notify the event handler about error cases so appropriate

            // actions can be taken.

            if ( KErrNone != err )

                {

                SendInternalRtpEventToClient( iEventHandler,

                                              KMccRtpSourceUid,

                                              KMccInternalRtpSrcMmfEvent,

                                              KMccStreamError,

                                              MCC_RTPSOURCE_ENDPOINT_ID,

                                              err );

                }

            }

		}

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::SetSourceDataTypeCode

// Sets the sources datatype code ( Codec )

// -----------------------------------------------------------------------------

//

TInt CMccRtpDataSource::SetSourceDataTypeCode( TFourCC aCodec, TMediaId /*aMedia*/ )

    {

    iCodecInfo.iFourCC = aCodec;

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::SourceDataTypeCode()

// Sets the datatype code ( codec )

// -----------------------------------------------------------------------------

//

TFourCC CMccRtpDataSource::SourceDataTypeCode( TMediaId /*aMediaId*/ )

    {

    return iCodecInfo.iFourCC;

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::BufferEmptiedL

// CMccRtpDataSource supports only passive mode of operation. 

// Thus, Datapath->EmptyBufferL isn't called.

// -----------------------------------------------------------------------------

//

void CMccRtpDataSource::BufferEmptiedL( CMMFBuffer* /*aBuffer*/ )

    {

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::BufferEmptiedL KErrNotSupported" )

    User::Leave( KErrNotSupported );

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::SourceThreadLogon

//

// Method to 'logon' the data source to the same thread that source will be 

// consuming data in. Thread specific initialisation is done here.

// -----------------------------------------------------------------------------

//

TInt CMccRtpDataSource::SourceThreadLogon( MAsyncEventHandler& aEventHandler )

    {

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::SourceThreadLogon" )

    TInt err( KErrNone );

    iEventHandler = &aEventHandler;

    if ( NULL == iJitCalc )

        {

        TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::SourceThreadLogon,\

            create jitter calculator" )

        TRAP( err, iJitCalc = CMccJitterCalculator::NewL( *this ) );

        }

    return err;

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::SourceThreadLogoff

//

// Method to 'logoff' the data source from the same thread that source consumes 

// data in. Thread specific releasing of resources is done here.

// -----------------------------------------------------------------------------

//

void CMccRtpDataSource::SourceThreadLogoff()

    {

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::SourceThreadLogoff" )

    StopKeepalive();

    iEventHandler = NULL;

    // Close the streams (if any)

    if ( KNullId != iRtpStreamId )

        {

        iRtpAPI->UnregisterRtpObserver( iSessionID );

    	}

	CloseStreams();

    iRtpAPI = NULL;

    iRtpStreamId = KNullId;

    iBufferToFill = NULL;

    delete iTimer;

    iTimer = NULL;

    delete iJitCalc;

    iJitCalc = NULL;

    }

// ---------------------------------------------------------------------------

// CMccRtpDataSource::SourcePrimeL

// Source must be primed before playing.

// -----------------------------------------------------------------------------

//

void CMccRtpDataSource::SourcePrimeL()

    {

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::SourcePrimeL" )

    SetStateL( ERtpStatePrimed );

    SendStreamEventToClient( KMccStreamPrepared ); 

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::SourcePlayL

// Start receiving RTP packets.

// -----------------------------------------------------------------------------

//

void CMccRtpDataSource::SourcePlayL()

    {

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::SourcePlayL" )

    if ( iSecureKeyExpired )

    	{

    	TRACE_RTP_SINK_PRINT( "Leave becuase the secure key expired" )

    	User::Leave( KErrGeneral );

    	}

	//Leave when is the secure evnet key expired and try to restart

    iPacketsReceived = 0;

    iDlStreamStarted = EFalse;

    TSourceSinkState oldState = State();

    __ASSERT_ALWAYS( iJitCalc, User::Leave( KErrNotFound ) );

    iJitCalc->ResetCounters();

    ResetStandBy();

    SetStateL( ERtpStatePlaying );

    // Enable keepalive while receiving (depending on codec settings)

    // Keepalive is not supported in recvonly secure sessions

    if ( !iSecSession )

        {

        StartKeepaliveL( *iRtpMediaClock );

        }

    if ( oldState == ERtpStatePaused )

        {

        SendStreamEventToClient( KMccStreamResumed ); 

        }

    else

        {

        SendStreamEventToClient( KMccStreamStarted ); 

        }

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::SourcePauseL

// Pause RTP packet receiving.

// -----------------------------------------------------------------------------

//

void CMccRtpDataSource::SourcePauseL()

    {

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::SourcePauseL" )

    iPacketsReceived = 0;

    __ASSERT_ALWAYS( iJitCalc, User::Leave( KErrNotFound ) );

    iJitCalc->ResetCounters();

    SetStateL( ERtpStatePaused );

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::SourcePauseL\

    stop standby timers" )

    StopRtpStandByTimers();

    SendStreamEventToClient( KMccStreamPaused ); 

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::SourceStopL

// Stop RTP packet receiving.

// -----------------------------------------------------------------------------

//

void CMccRtpDataSource::SourceStopL()

    {

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::SourceStopL" )

    iDlStreamStarted = EFalse;

    SetStateL( ERtpStateStopped );

    StopKeepalive();

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::SourceStopL,\

    Stop standby timers" )

    StopRtpStandByTimers();

    SendStreamEventToClient( KMccStreamStopped ); 

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::PlayoutRtpPacketL

// Pass filled buffer to the data sink of RTP data source.

// -----------------------------------------------------------------------------

//

void CMccRtpDataSource::PlayoutRtpPacketL( const TRtpRecvHeader& aHeaderInfo, 

        const TDesC8& aPayloadData )

    {

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::PlayoutRtpPacketL" )

    __ASSERT_ALWAYS( iBufferToFill, User::Leave( KErrNotReady ) );

    __ASSERT_ALWAYS( iFillBufferRequester, User::Leave( KErrNotReady ) );

    iBufferToFill->Data().Copy( aPayloadData );

    CPayloadFormatRead* sink = static_cast<CPayloadFormatRead*>( iFillBufferRequester );

    User::LeaveIfNull( sink );

    sink->DataBufferFilledL( iBufferToFill, aHeaderInfo );

    }

// -----------------------------------------------------------------------------

// CMccRtpDataSource::DoCreateStreamL

// Creates a receive stream.

// -----------------------------------------------------------------------------

//

void CMccRtpDataSource::DoCreateStreamL()

    {

    TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::DoCreateStreamL IN !!!!" )

    __ASSERT_ALWAYS( KNullId == iRtpStreamId, User::Leave( KErrAlreadyExists ) );

    __ASSERT_ALWAYS( NULL != iRtpAPI, User::Leave( KErrNotReady ) );

    TRcvStreamParams rcvParams;

    rcvParams.iPayloadType = iCodecInfo.iPayloadType;

    TRACE_RTP_SOURCE_PRINT2( "CMccRtpDataSource::DoCreateStreamL CONFIGURED_PT: %u",

        iCodecInfo.iPayloadType )

    iRtpStreamId = iRtpAPI->CreateReceiveStreamL( iSessionID, rcvParams );

    if ( KNullId == iRtpStreamId )

        {

        TRACE_RTP_SOURCE_PRINT( "CMccRtpDataSource::DoCreateStreamL KErrCouldNotConnect 1" )