/*

* 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:    Provides a comfort noise generator class

*

*/

// INCLUDE FILES

#include    <rtpheader.h> 

#include 	<e32cmn.h>

#include 	<utf.h> // charconv.lib

#include    "msrppayloadformatwrite.h" 

#include    "mccrtpdatasink.h"

#include 	"Mccrtpinterface.h"

#include    "mccmsrpformatlogs.h"

#include    "mccuids.hrh"

#include    "mccdef.h"

#include    "mccrtpmediaclock.h"

#include    "mccinternaldef.h"

#include 	"msrppayloadformatdefs.h"

#include    "mmccinterfacedef.h"

#include    "mccmsrpsink.h"

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

// CMsrpPayloadFormatRead::CMsrpPayloadFormatRead

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

// might leave.

// 

// iIdleMode is set to ETrue, because when starting we are in IdleMode

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

//

CMsrpPayloadFormatWrite::CMsrpPayloadFormatWrite(): iIdleMode(ETrue)

    {    

    }

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

// CMsrpPayloadFormatWrite::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMsrpPayloadFormatWrite::ConstructL ( MDataSink* aSink )

    {

    DP_MSRP_WRITE("CMsrpPayloadFormatWrite::ConstructL");

    // Set default values

    iFourCC = KMccFourCCIdMSRP ;

    //iFourCC.Set( TFourCC( 'T','1','4','0' ) );

	//we are going upstream, so our source is the datapath and

	// sink is the clip. If we use RTP, which  we do, 

	// our sink is of cource the RTPSink

    iClip = aSink;    

    iIsRtpSink = ( KMccRtpSinkUid  == aSink->DataSinkType() );

    iIsMsrpSink = (KMccMsrpSinkUid == aSink->DataSinkType() );

    // two levels of redundancy is allways assumed, not necessarily used

    // RFC4103 RECOMMENDED

    iRedData = new(ELeave)CArrayFixFlat<TStringElement>(3);

    //userBuffer, handles all data put in by user

    iUserBuffer = new(ELeave)CArrayFixFlat<TStringElement>(3);

    // init data to null

    TStringElement one;

    TStringElement two;

    TStringElement three;

    iRedData->AppendL(one);

    iRedData->AppendL(two); 

    iRedData->AppendL(three);

    // maxsize of the packet

    iBuf = HBufC8::NewL( KRedHeaderSize + KDataSize );

    iData = const_cast<TUint8*>( iBuf->Des().Ptr() );

    if ( iIsRtpSink )

        {

        CMccRtpDataSink* tmp = static_cast<CMccRtpDataSink*>( aSink );

        iRtpDataSink = static_cast<MMccRtpDataSink*>( tmp );

        }

    else if(iIsMsrpSink)

        {

        CMccMsrpSink *tmp = static_cast<CMccMsrpSink*>( aSink );

        iMsrpDataSink = static_cast<CMccMsrpSink*>( tmp );

        }

    else

        {

    	DP_MSRP_WRITE("CMsrpPayloadFormatWrite::ConstructL Leaving: No RTPSink!");

    	User::Leave(KErrNotSupported);	

        }

    // Initialize state machine

    iStateMachine = CFormatEncodeStateMachine::NewL( this );

    //init state machine to idle state

    iStateMachine->ChangeState( EEncodeIdle );

    // Construct Timer for redundant generations.

    iTimer = CSendStateMachine::NewL( this ); 

    }

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

// CMsrpPayloadFormatWrite::NewL

// Two-phased constructor.

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

//

CMsrpPayloadFormatWrite* CMsrpPayloadFormatWrite::NewL ( MDataSink* aSink )

    {

 	DP_MSRP_WRITE( "CMsrpPayloadFormatWrite::NewL" );

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

    CMsrpPayloadFormatWrite* self = new (ELeave) CMsrpPayloadFormatWrite;

    CleanupStack::PushL( self );

    self->ConstructL( aSink );

    CleanupStack::Pop( self );

    return self;

    }

// Destructor 

CMsrpPayloadFormatWrite::~CMsrpPayloadFormatWrite ()

    {

    if ( iStateMachine )

        {

        iStateMachine->Cancel();

        delete iStateMachine;

        }

    if(iTimer) 

	    {

	    	iTimer->Cancel();

	    	delete iTimer;	

	    }

    iRtpMediaClock = NULL;

    iClip = NULL;

    delete iSourceBuffer;

    delete iSinkBuffer;

    delete iRedData;

    delete iUserBuffer;

    delete iBuf;

    }

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

// CMsrpPayloadFormatWrite::SinkThreadLogon

// Passes the logon command to the sink clip

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

//

TInt CMsrpPayloadFormatWrite::SinkThreadLogon(MAsyncEventHandler& aEventHandler)

    {

    DP_MSRP_WRITE("CMsrpPayloadFormatWrite::SinkThreadLogon");

    iClip->SinkThreadLogon( aEventHandler );

    return KErrNone;

    }

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

// CMsrpPayloadFormatWrite::SinkThreadLogoff

// Passes the logoff command to the sink clip

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

void CMsrpPayloadFormatWrite::SinkThreadLogoff()

    {   

    DP_MSRP_WRITE("CMsrpPayloadFormatWrite::SinkThreadLogoff");

    iClip->SinkThreadLogoff();

    }

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

// CMsrpPayloadFormatWrite::CreateSinkBufferL

// Create a sink buffer

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

//

CMMFBuffer* CMsrpPayloadFormatWrite::CreateSinkBufferL( TMediaId /*aMediaId*/,

                                                        TBool &aReference )

    { 

   	DP_MSRP_WRITE( "CMsrpPayloadFormatWrite::CreateSinkBufferL" );

	/* TODO: Remove me when platform supports

    if ( KUidMediaTypeText != aMediaId.iMediaType ) 

    {

    User::Leave( KErrNotSupported ); 

    }

    */    

    aReference = ETrue;

    return CreateSinkBufferOfSizeL( KMaxRTTChunkSize + KRedHeaderSize );

    }

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

// CMsrpPayloadFormatWrite::CreateSinkBufferOfSizeL

// Create a sink buffer of the given size.

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

//

CMMFDataBuffer* CMsrpPayloadFormatWrite::CreateSinkBufferOfSizeL( TUint aSize )

    {

	DP_MSRP_WRITE( "CMsrpPayloadFormatWrite::CreateSinkBufferOfSizeL" );

    if ( !iSourceBuffer )

	    {

	    iSourceBuffer = CMMFDataBuffer::NewL( aSize );

    	iSourceBuffer->Data().FillZ( aSize );

    	iSourceBuffer->SetRequestSizeL( aSize );

	    }

    return iSourceBuffer;

    }

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

// CMsrpPayloadFormatWrite::EmptyBufferL

// Empty the given source buffer

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

//

void CMsrpPayloadFormatWrite::EmptyBufferL( CMMFBuffer* aBuffer, 

                                            MDataSource* aSupplier, 

                                            TMediaId /*aMediaId*/ )

    {

    DP_MSRP_WRITE("CMsrpPayloadFormatWrite::EmptyBufferL");

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

    __ASSERT_ALWAYS ( aBuffer == iSourceBuffer, User::Leave( KErrArgument ) );

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

   	// TODO: Remove me when platform supports

	// __ASSERT_ALWAYS( KUidMediaTypeAudio == aMediaId.iMediaType,

	// User::Leave( KErrNotSupported ) );

    // Cancel timer, so timer does not interrupt our current sending.

    // Timer enables empty blocks to be appended when redundancy is on.

    iTimer->Cancel();

    iDataPath = aSupplier;

    iSourceBuffer = static_cast<CMMFDataBuffer*>( aBuffer );

    if ( !iSinkBuffer )

        {        

        iStateMachine->ChangeState( ESourceBufferEmptied );

        return;

        }

	if ( !iSinkBuffer->Data().Length() ) 

	    {

		//User::LeaveIfError( iRtpMediaClock->GetTimeStamp( iKey, iCurrentTimestamp ) );

   		iSinkBuffer->SetTimeToPlay( TInt64( iCurrentTimestamp ) );

   		iSinkBuffer->SetFrameNumber( aBuffer->FrameNumber() );	

	    }

      // We signal StateMachine to ChangeState() 

      // this calls back EmptySourceBufferL 

      iStateMachine->ChangeState( EEmptySourceBuffer );

    } 

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

// CMsrpPayloadFormatWrite::SetSinkDataTypeCode

// Set the sink data type to the given four CC code for the given media

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

//

TInt CMsrpPayloadFormatWrite::SetSinkDataTypeCode( TFourCC aSinkFourCC,

                                                   TMediaId /*aMediaId*/ )

    {

    DP_MSRP_WRITE("CMsrpPayloadFormatWrite::SetSinkDataTypeCode");

	/* TODO: Remove me when platform supports

    if ( KUidMediaTypeText != aMediaId.iMediaType )

    {

    User::Leave( KErrNotSupported );

    }

    */

    iFourCC = aSinkFourCC;

    return KErrNone;

    }

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

// CMsrpPayloadFormatWrite::SinkDataTypeCode

// Return the sink data type (four CC code) for the given media ID

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

//

TFourCC CMsrpPayloadFormatWrite::SinkDataTypeCode( TMediaId /*aMediaId*/ )

    {

    DP_MSRP_WRITE("CMsrpPayloadFormatWrite::SinkDataTypeCode");

  	/* TODO: Remove me when platform supports

    if ( KUidMediaTypeText == aMediaId.iMediaType )

        {

        return iFourCC;

        }

    else

        {

        return TFourCC(); //defaults to 'NULL' fourCC

        }

        */

	return iFourCC;

    }

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

// CMsrpPayloadFormatWrite::BufferEmptiedL

// Called after payload buffer is completely emptied by RtpDataSink.

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

//

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

    {

    DP_MSRP_WRITE( "CMsrpPayloadFormatWrite::BufferEmptiedL" );

	// nothing to be done

	//NOTE: 14.12.2007 - LeaveScan causes warning, but this is a interface method

    }

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

// CMsrpPayloadFormatWrite::FrameTimeInterval

// Return the frame time interval for the given media

// Return allways 0

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

//

TTimeIntervalMicroSeconds 

    CMsrpPayloadFormatWrite::FrameTimeInterval( TMediaId /*aMediaId*/ ) const

    {

    DP_MSRP_WRITE( "CMsrpPayloadFormatWrite::FrameTimeInterval" );

    return TTimeIntervalMicroSeconds( TInt64( 0 ) );

    }

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

// CMsrpPayloadFormatWrite::Duration

// Return the frame time interval for the given media

// NOT SUPPORTED

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

//

TTimeIntervalMicroSeconds 

    CMsrpPayloadFormatWrite::Duration( TMediaId /*aMediaType*/ ) const

    {

    DP_MSRP_WRITE( "CMsrpPayloadFormatWrite::Duration" );

    return TTimeIntervalMicroSeconds( TInt64( 0 ) );

    }

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

// CMsrpPayloadFormatWrite::EmptySourceBufferL

// Empty the given sourcebuffer

// Sourcebuffer is given in iSourceBuffer

// Called by StateMachine

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

//

void CMsrpPayloadFormatWrite::EmptySourceBufferL()

	{

	  	DP_MSRP_WRITE( "CMsrpPayloadFormatWrite::EmptySourceBufferL" );

	  	const TDesC8& srcDes( iSourceBuffer->Data() );

    	const TUint8* srcPtr = srcDes.Ptr();

  		TInt length = iSourceBuffer->Data().Length();

  		if ( iSourceBuffer->Data().Length() ) 

	  		{

		  		if( KMaxRTTChunkSize < length )

				  	{

				  		DP_MSRP_WRITE( "ERR - RTT Payload Length exceeded MaxChunkSize" );

				  		User::Leave(KErrArgument);

				  	}

		  		TBuf16<KMaxRTTChunkSize> unicode;

		    	User::LeaveIfError(

		    			CnvUtfConverter::ConvertToUnicodeFromUtf8(unicode, TPtrC8(srcPtr)));			

				//buffer the user data

				TStringElement buffer;

				buffer.iData = unicode;

				iUserBuffer->AppendL(buffer);

				FormUserDataL();

				ForwardDataL();

			}

}   

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

// CMsrpPayloadFormatWrite::TimerExpiredL()

// Sends Redundant data after buffer period, if no user data 

// appeared before that.

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

//

void CMsrpPayloadFormatWrite::TimerExpiredL()

{		

	DP_MSRP_WRITE( "CMsrpPayloadFormatWrite::TimerExpiredL" );

	// Because timer expired, we must send redundant data anyway

	TStringElement nullData;

	iUserBuffer->AppendL(nullData);

	FormUserDataL();

	//TODO:Handle other Errors if any

	TInt err = SendRedundantDataL();

	if ( err != KErrNone )

		{

			GotoIdleL(); 

		}

}

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

// CMsrpPayloadFormatWrite::ForwardDataL()

// Sends Redundant data after buffer period, if no user data 

// appeared before that.

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

//

void CMsrpPayloadFormatWrite::ForwardDataL()

{

    DP_MSRP_WRITE( "CMsrpPayloadFormatWrite::ForwardDataL" );

    // Just Send Data

    TInt err = SendRedundantDataL();

    if ( err == KErrNone )

        {

            iStateMachine->ChangeState( ESourceBufferEmptied ); 

        }

} 

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

// CMsrpPayloadFormatWrite::SendRedundantDataL()

// A Method that sends the redundant buffer to Sink

// Calls CMsrpPayloadFormatWrite::DeliverPacketL

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

//

TInt CMsrpPayloadFormatWrite::SendRedundantDataL()

	{

    DP_MSRP_WRITE( "CMsrpPayloadFormatWrite::SendRedundantDataL" );

	TStringElement zero = iRedData->At(0);

	TStringElement one = iRedData->At(1);

	TStringElement two = iRedData->At(2);

 	DP_MSRP_WRITE( "******************");

 	DP_MSRP_WRITE2( "SendRedundantDataL - Zero Lenght: %d", zero.iData.Length() ); 

 	DP_MSRP_WRITE2( "SendRedundantDataL - R1 Lenght: %d", one.iData.Length() );

 	DP_MSRP_WRITE2( "SendRedundantDataL - R2 lenght: %d", two.iData.Length() );

	if ( zero.iData.Length() == 0 && one.iData.Length() == 0 && two.iData.Length() == 0 )

	 {

	 	DP_MSRP_WRITE( "ERR - SendRedundantDataL - All Data is 0 lenght returning, KErrArgument!"); 

	 	return KErrArgument;

	 }

	TDes8& destDes( iSinkBuffer->Data() );

 	// Assemble redundant data

    AssembleRedPacket();

    // Append current data to buffer

    TPtr8 ptr = iBuf->Des();

    destDes.Append(  ptr );

    DP_MSRP_WRITE2( "CMsrpPayloadFormatWrite HeapData size: %d", ptr.Size() );

    DP_MSRP_WRITE2( "CMsrpPayloadFormatWrite HeapData Length: %d", ptr.Length() );

    DP_MSRP_WRITE ("CMsrpPayloadFormatWrite::DeliverPacketL, Packet Assembled" );

	DP_MSRP_WRITE( "******************");

    DeliverPacketL( *iSinkBuffer );	

	return KErrNone;

	}

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

// CMsrpPayloadFormatWrite::FormUserDataL()

//

// A function that refreshes the RedundantData Buffer, so that

// We just can send data that is there.

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

//

TInt CMsrpPayloadFormatWrite::FormUserDataL()

{

    DP_MSRP_WRITE( "CMsrpPayloadFormatWrite::SendRedundantDataL" );

    TStringElement primary;

    // if there is data

    if ( iUserBuffer->Count() )

        {

            primary = iUserBuffer->At(0);

        }

    //set timestamp to primary data, this is used to calculate offset

    primary.iTimestamp = iSinkBuffer->TimeToPlay().Int64();

    // can now reset user buffer

    iUserBuffer->Reset();

    // get current redundants

    TStringElement zero = iRedData->At(0);

    TStringElement one = iRedData->At(1); 

    // we can now reset old redundant also

    iRedData->Reset();

    // re-order redundant data, this must be always present,