/*

* Copyright (c) 2004-2006 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:    Payload format component capable to write RTP payload

*                containing AMR audio.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <mmf/common/mmffourcc.h>

#include "amrpayloadformatwrite.h"

#include "amrpayloadencoder.h"

#include "amrpayloadencoderoa.h"

#include "amrpayloaddecoder.h"

#include "amrcommonutil.h"

#include "mccrtpdatasink.h"

#include "mccuids.hrh"

#include "mccdef.h"

#include "mccinternaldef.h"

#include "amrpayloadformatter.h"

#include "mccrtpmediaclock.h" 

#include "mccredpayloadwrite.h"

#ifdef VOIP_TRACE_ENABLED

#include <voip_trace.h>

#endif

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

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

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

// CAmrPayloadFormatWrite::CAmrPayloadFormatWrite

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

// might leave.

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

//

CAmrPayloadFormatWrite::CAmrPayloadFormatWrite( )

    : iSamplingRate( KAmrNbSampleRate ), iChannels( 1 )

    {

    }

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

// CAmrPayloadFormatWrite::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAmrPayloadFormatWrite::ConstructL ( MDataSink* aSink )

    {

    // Set default values

    iFramesPerPacket = 1;

    iFourCC.Set( TFourCC( ' ','A','M','R' ) );

    // Set data sink

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

    if ( iIsRtpSink )

        {

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

        iRtpDataSink = static_cast<MMccRtpDataSink*>( tmp );

        }

    iClip = aSink;

    }

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

// CAmrPayloadFormatWrite::NewL

// Two-phased constructor.

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

//

CAmrPayloadFormatWrite* CAmrPayloadFormatWrite::NewL( MDataSink* aSink )

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        RDebug::Print( _L("CAmrPayloadFormatWrite::NewL") );

    #endif

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

    CAmrPayloadFormatWrite* self = new ( ELeave ) CAmrPayloadFormatWrite;

    CleanupStack::PushL( self );

    self->ConstructL( aSink );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAmrPayloadFormatWrite::~CAmrPayloadFormatWrite

// Destructor.

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

//

CAmrPayloadFormatWrite::~CAmrPayloadFormatWrite ( )

    {

    delete iSourceBuffer;

    iRtpDataSink = NULL;

    iClip = NULL;

    delete iSinkBuffer;

    delete iStateMachine;

    delete iPayloadEncoder;

    iModes.Close();

    iRtpMediaClock = NULL;

    }

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

// CAmrPayloadFormatWrite::FrameTimeInterval

//

// Return the frame time interval for the given media

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

//

TTimeIntervalMicroSeconds CAmrPayloadFormatWrite::FrameTimeInterval( 

        TMediaId aMediaId ) const

    {

    if ( KUidMediaTypeAudio == aMediaId.iMediaType )

        {

        TInt hwFrametime = static_cast<TInt>( iCInfo.iHwFrameTime );

        return TTimeIntervalMicroSeconds( TInt64( hwFrametime ) );

        }

    else

        {

        return TTimeIntervalMicroSeconds( TInt64( 0 ) );

        }

    }

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

// CAmrPayloadFormatWrite::CreateSinkBufferL

//

// Create a source buffer for the given media and indicate in aReference if buffer

// is created.

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

//

CMMFBuffer* CAmrPayloadFormatWrite::CreateSinkBufferL( TMediaId aMediaId, 

                                                       TBool &aReference )

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        AMR_PAYLOAD_FORMAT_WRITE ( "CAmrPayloadFormatWrite::CreateSinkBufferL( )" );

    #endif

    #ifdef VOIP_TRACE_ENABLED

        VoipTrace( "%x %x", MCC_TRACE, MCC_AMR_PLF_WRITE_CREATESINKBUFFERL );

    #endif

    if ( KUidMediaTypeAudio != aMediaId.iMediaType )

        {

        User::Leave( KErrNotSupported );

        }

    // the ownership of iSourceBuffer is in CAmrPayloadFormatWrite

    aReference = ETrue;

   	return CreateSinkBufferOfSizeL( iCInfo.iFrameSize );

    }

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

// CAmrPayloadFormatWrite::SinkDataTypeCode

//

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

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

//

TFourCC CAmrPayloadFormatWrite::SinkDataTypeCode( TMediaId aMediaId )

    {

    if ( KUidMediaTypeAudio == aMediaId.iMediaType ) 

        {

        return iFourCC;

        }

    else 

        {

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

        }

    }

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

// CAmrPayloadFormatWrite::SetSinkDataTypeCode

//

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

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

//

TInt CAmrPayloadFormatWrite::SetSinkDataTypeCode( TFourCC aSinkFourCC, 

                                                  TMediaId aMediaId )

    {

    #ifdef VOIP_TRACE_ENABLED

        VoipTrace( "%x %x %d", MCC_TRACE, MCC_AMR_PLF_WRITE_SETSINKDATATYPECODE,

            aSinkFourCC.FourCC() );

    #endif

    if ( KUidMediaTypeAudio != aMediaId.iMediaType )

        {

        return KErrNotSupported;

        }

    else 

        {

        iFourCC = aSinkFourCC;

        }

    return KErrNone;

    }

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

// CAmrPayloadFormatWrite::SinkThreadLogon

//

// Passes the logon command to the sink clip

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

//

TInt CAmrPayloadFormatWrite::SinkThreadLogon( MAsyncEventHandler& aEventHandler )

    {

    #ifdef VOIP_TRACE_ENABLED

        VoipTrace( "%x %x", MCC_TRACE, MCC_AMR_PLF_WRITE_SINKTHREADLOGON );

    #endif

    iClip->SinkThreadLogon( aEventHandler );

    return KErrNone;

    }

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

// CAmrPayloadFormatWrite::SinkThreadLogoff

//

// Log out of the sink thread.

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

//

void CAmrPayloadFormatWrite::SinkThreadLogoff( )

    {

    #ifdef VOIP_TRACE_ENABLED

        VoipTrace( "%x %x", MCC_TRACE, MCC_AMR_PLF_WRITE_SINKTHREADLOGOFF );

    #endif

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        AMR_PAYLOAD_FORMAT_WRITE( "CAmrPayloadFormatWrite::SinkThreadLogoff " );

    #endif   

    iClip->SinkThreadLogoff( );

    }

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

// CAmrPayloadFormatWrite::ProcessFramesL

//

// Packetize the AMR frames received from AMR codec and deliver the packets.

// The AMR frames are stored in "iSourceBuffer".

// return value - Current talk spurt finished, ETrue. Otherwise, EFalse.

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

//

TBool CAmrPayloadFormatWrite::ProcessFramesL( )

    {

    return ETrue;

    }

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

// CAmrPayloadFormatWrite::DeliverPacketL

//

// Prepare packet header and deliver the packet to the datasink.

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

//

void CAmrPayloadFormatWrite::DeliverPacketL( CMMFDataBuffer& aPayload )

    {

    AMR_PAYLOAD_FORMAT_WRITE2( "CAmrPayloadFormatWrite::DeliverPacketL - TSTAMP: %u",

        static_cast<TUint32>( aPayload.TimeToPlay().Int64() ) );

    }

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

// CAmrPayloadFormatWrite::EmptyBufferL

//

// Empty the given source buffer by formatting the AMR frames into RTP payload.

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

//

void CAmrPayloadFormatWrite::EmptyBufferL( CMMFBuffer* /*aBuffer*/, 

                                           MDataSource* /*aSupplier*/, 

                                           TMediaId /*aMediaId*/ )

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        AMR_PAYLOAD_FORMAT_WRITE( "CAmrPayloadFormatWrite::EmptyBufferL( )" );

    #endif

    }

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

// CAmrPayloadFormatWrite::EmptySourceBufferL

//

// Empty the given source buffer by formatting the AMR frames into RTP payload.

// Source buffer is given in "iSourceBuffer".

// Called by the state machine.

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

//

void CAmrPayloadFormatWrite::EmptySourceBufferL( )

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        AMR_PAYLOAD_FORMAT_WRITE( "CAmrPayloadFormatWrite::EmptySourceBufferL" );

    #endif

    }

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

// CAmrPayloadFormatWrite::SourceBufferEmptiedL

//

// Hanlde the event that source buffer has been emptied.

// Source buffer is given in "iSourceBuffer".

// Called by the state machine.

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

//

void CAmrPayloadFormatWrite::SourceBufferEmptiedL()

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        AMR_PAYLOAD_FORMAT_WRITE ( "CAmrPayloadFormatWrite::SourceBufferEmptiedL" );

    #endif

    }

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

// CAmrPayloadFormatWrite::BufferEmptiedL

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

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

//

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

    {

    }

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

// CAmrPayloadFormatWrite::NumChannels

//

// Get the number of channels

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

//

TUint CAmrPayloadFormatWrite::NumChannels( )

    {

    return iChannels;

    }

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

// CAmrPayloadFormatWrite::SampleRate

//

// Get packetization rate.

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

//

TUint CAmrPayloadFormatWrite::SampleRate( )

    {

    return iSamplingRate;

    }

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

// CAmrPayloadFormatWrite::SetSampleRate

// 

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

//

TInt CAmrPayloadFormatWrite::SetSampleRate ( TUint aSampleRate )

    {

    #ifdef VOIP_TRACE_ENABLED

        VoipTrace( "%x %x %d", MCC_TRACE, MCC_AMR_PLF_WRITE_SETSAMPLERATE,

            aSampleRate );

    #endif

    if( KAmrNbSampleRate != aSampleRate )

        {

        return KErrNotSupported;

        }

    else

        {

        iSamplingRate = aSampleRate;

        return KErrNone;

        }

    }

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

// CAmrPayloadFormatWrite::Duration

//

// Return the clip duration for the given media.

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

//

TTimeIntervalMicroSeconds CAmrPayloadFormatWrite::Duration( 

        TMediaId /*aMediaType*/ ) const

    {

    return TTimeIntervalMicroSeconds( TInt64( 0 ) );

    }

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

// CAmrPayloadFormatWrite::CreateSinkBufferOfSizeL

//

// Create a sink buffer of the given size.

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

//

CMMFDataBuffer* CAmrPayloadFormatWrite::CreateSinkBufferOfSizeL( TUint aSize )

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        AMR_PAYLOAD_FORMAT_WRITE ( "CAmrPayloadFormatWrite::CreateSinkBufferOfSizeL( )" );

    #endif

    #ifdef VOIP_TRACE_ENABLED

        VoipTrace( "%x %x %d", MCC_TRACE, MCC_AMR_PLF_WRITE_CREATESINKBUFFEROFSIZEL,

            aSize );

    #endif

    if ( !iSourceBuffer )

	    {  

	    iSourceBuffer = CMMFDataBuffer::NewL( aSize );

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

    	iSourceBuffer->SetRequestSizeL( aSize );

	    }

    return iSourceBuffer;

    }

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

// CAmrPayloadFormatWrite::IsBitrateChangeValid

// Checks if codec mode change request is valid.

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

//

TBool CAmrPayloadFormatWrite::IsBitrateChangeValid( TInt /*aBitRate*/ ) 

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        AMR_PAYLOAD_FORMAT_WRITE( "CAmrPayloadFormatWrite::IsBitrateChangeValid" );

    #endif

    return ETrue;

    }

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

// CAmrPayloadFormatWrite::CancelUlRequest

// Cancel UL Request

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

//

void CAmrPayloadFormatWrite::CancelUlRequest( )

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        AMR_PAYLOAD_FORMAT_WRITE( "CAmrPayloadFormatWrite::CancelUlRequest" );

    #endif

    }

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

// CAmrPayloadFormatWrite::SinkPrimeL()

// Primes sink

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

//

void CAmrPayloadFormatWrite::SinkPrimeL()

    {

    #ifdef VOIP_TRACE_ENABLED

        VoipTrace( "%x %x", MCC_TRACE, MCC_AMR_PLF_WRITE_SINKPRIMEL );

    #endif

    iClip->SinkPrimeL();

    };

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

// CAmrPayloadFormatWrite::SinkPlayL()

// Plays sink

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

//

void CAmrPayloadFormatWrite::SinkPlayL()

    {

    #ifdef VOIP_TRACE_ENABLED

        VoipTrace( "%x %x %d", MCC_TRACE, MCC_AMR_PLF_WRITE_SINKPLAYL, iCInfo.iRedundancyCount );

    #endif

    iClip->SinkPlayL();

    };

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

// CAmrPayloadFormatWrite::SinkPauseL()

// Pauses sink

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

//

void CAmrPayloadFormatWrite::SinkPauseL()

    {

    #ifdef VOIP_TRACE_ENABLED

        VoipTrace( "%x %x", MCC_TRACE, MCC_AMR_PLF_WRITE_SINKPAUSEL );

    #endif

    this->CancelUlRequest();

    iClip->SinkPauseL();

    };

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

// CAmrPayloadFormatWrite::SinkStopL()

// Stops sink

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

//

void CAmrPayloadFormatWrite::SinkStopL()

    {

    #ifdef VOIP_TRACE_ENABLED

        VoipTrace( "%x %x", MCC_TRACE, MCC_AMR_PLF_WRITE_SINKSTOPL );

    #endif

    this->CancelUlRequest();

    iClip->SinkStopL();

    };

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

// CAmrPayloadFormatWrite::ConfigurePayloadFormatL

// Configure payload encoding parameters.

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

//

void CAmrPayloadFormatWrite::ConfigurePayloadFormatL( 

        const TDesC8& aConfigParams, 

        CMccRtpMediaClock& /*aClock*/  )

    {

    if ( aConfigParams.Size() == sizeof( TMccCodecInfo ) )

        {

        #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

            AMR_PAYLOAD_FORMAT_WRITE( "CAmrPayloadFormatWrite::ConfigurePayloadFormatL IN" );

        #endif

        TMccCodecInfoBuffer infoBuffer;

        infoBuffer.Copy( aConfigParams );

        iCInfo = infoBuffer();

        }

    else

        {

        #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

            AMR_PAYLOAD_FORMAT_WRITE( "CAmrPayloadFormatWrite::ConfigurePayloadFormatL KErrArgument 2" );

        #endif

        User::Leave( KErrArgument );

        }

    }

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

// CAmrPayloadFormatWrite::UpdateConfigurationL

// Update payload encoding parameters

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

//