/*

* Copyright (c) 2004-2007 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"

const TUint KSampleRate8kHz = 8;

const TUint KSampleRate16kHz = 16;

const TReal KTimeMultiplier = 0.001;

// MACROS

#define MCC_AUDIO_TIMESTAMP( a ) \

TUint32( iFramesPerPacket * a * iChannels * \

         (iIsNb?KSampleRate8kHz:KSampleRate16kHz) * KTimeMultiplier )

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

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

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

// CAmrPayloadFormatWrite::CAmrPayloadFormatWrite

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

// might leave.

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

//

CAmrPayloadFormatWrite::CAmrPayloadFormatWrite( )

    : iIsNb( ETrue ), 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() );

    TBool isRedEncoder 

        = ( TUid::Uid( KImplUidRedPayloadFormatEncode ) == aSink->DataSinkType() );

    if ( iIsRtpSink )

        {

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

        iRtpDataSink = static_cast<MMccRtpDataSink*>( tmp );

        }

    else if ( isRedEncoder )

        {

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

        iRtpDataSink = static_cast<MMccRtpDataSink*>( tmp );

        iIsRtpSink = ETrue;

        }

    else

        {

        AMR_PAYLOAD_FORMAT_WRITE( "CAmrPayloadFormatWrite::ConstructL, not RTP sink" )

        }

    iClip = aSink;

    // Set default set of modes

    for ( TInt i = 0; i < KNumberOfNbModes; i++ )

        {

        iModes.Append( KAmrNbModes[i] );

        }

    // Initialize state machine

    iStateMachine = CFormatEncodeStateMachine::NewL( this );

    iStateMachine->ChangeState( EEncodeIdle );

    }

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

// 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;

    delete iSinkBuffer;

    delete iStateMachine;

    delete iPayloadEncoder;

    iModes.Close();

    // Media clock is not owned

    if ( iRtpMediaClock )

        {

        iRtpMediaClock->UnregisterMediaFormat( iKey );

        }

    }

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

// 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

    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 ) 

        {

         #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        	AMR_PAYLOAD_FORMAT_WRITE2( 

        		"CAmrPayloadFormatWrite::SinkDataTypeCode: 0x%x", iFourCC.FourCC() );

        #endif

        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 TRACE_AMR_PAYLOAD_FORMAT_WRITE

        	AMR_PAYLOAD_FORMAT_WRITE2( 

        		"CAmrPayloadFormatWrite::SetSinkDataTypeCode: 0x%x", 

        		aSinkFourCC.FourCC() );

    #endif

    if ( KUidMediaTypeAudio != aMediaId.iMediaType )

        {

        return KErrNotSupported;

        }

    else if ( aSinkFourCC == KMccFourCCIdAMRNB )

        {

        iFourCC = aSinkFourCC;

        }

    else if ( aSinkFourCC == KMccFourCCIdAMRWB )

        {

        iFourCC = aSinkFourCC;

        // Nb modes were set in the construtor. We need to replace them with wb modes.

        iIsNb = EFalse; 

        iModes.Reset();

	    for ( TInt i = 0; i < KNumberOfWbModes; i++ )

	        {

	        iModes.Append( KAmrWbModes[i] );

	        }

	    SetSampleRate( KAmrWbSampleRate );

        }

    else

        {

        return KErrNotSupported;

        }

    return KErrNone;

    }

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

// CAmrPayloadFormatWrite::SinkThreadLogon

// Passes the logon command to the sink clip

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

//

TInt CAmrPayloadFormatWrite::SinkThreadLogon( MAsyncEventHandler& aEventHandler )

    {

    iClip->SinkThreadLogon( aEventHandler );

    return KErrNone;

    }

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

// CAmrPayloadFormatWrite::SinkThreadLogoff

// Log out of the sink thread.

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

//

void CAmrPayloadFormatWrite::SinkThreadLogoff( )

    {

    #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()

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        AMR_PAYLOAD_FORMAT_WRITE ( "CAmrPayloadFormatWrite::ProcessFramesL( ) Begin" );

    #endif

    TBool payloadReady( EFalse );

    TBool isDone( EFalse );

    TAmrFrameInfo frameInfo;

    CMMFBuffer* buffer = iSourceBuffer;

    TDes8& srcDes = ( static_cast<CMMFDataBuffer*>( buffer )->Data() );

    TInt readLen = srcDes.Length();

    TInt byteIndex = 0;

    TInt seekLen = readLen - byteIndex;

    const TUint8* seekPtr = srcDes.Ptr() + byteIndex;

    while ( seekLen >= CAmrCommonUtility::FrameHeaderSize() )

        {

        // Scan frame by frame until free format frame or EOB detected.

        TInt length = CAmrCommonUtility::FrameInfo( seekPtr, seekLen, frameInfo, iIsNb );

        if ( length > 0 && frameInfo.iBitrate > 0 ) // got a frame

            {

            TStreamDecoder decoder;

            decoder.Initialize( seekPtr, 0, 0 );

            decoder.Decode( 1 );                              // Skip first Padding bit

            TInt frameType( decoder.Decode( KNumValue4 ) ); // FT value

            TUint8 qualityInd = TUint8( decoder.Decode( 1 ) );// QualityInd value

            // Encode a frame, speech data starts from the second byte in a frame

            TPtr8 dataPtr( const_cast<TUint8*>( seekPtr+1 ), seekLen - 1, seekLen - 1 );

            #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

                RDebug::Print( _L("CAmrPayloadFormatWrite::ProcessFramesL frameType: %d"), frameType );

            #endif

            // frameType 8 (SID) or 15 (NO_DATA) tells us that we can set the 

            // CMR to NO_REQUEST, otherwise we can keep the CMR in which ever

            // the frameType is as they map directly to each other.

            // NOTE: There is no clear information on how to set the CMR field

            // regarding SID or NO_DATA frames. So there might be a possibility

            // that we should keep the original CMR also for SID and NO_DATA 

            // frames.

            // In the old implementation, the iPayloadEncoder used always the

            // same (moderequest for 12.2kbps) but this should be the correct

            // way of things.

            TAmrModeRequest modeReq;

            if ( ( iIsNb && ( frameType == EAmrFrameNoData || frameType == EAmrFrameSid ) ) ||

                 ( !iIsNb && ( frameType == EAmrWbFrameNoData || frameType == EAmrWbFrameSid  ) ) )

                {

                #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

                    RDebug::Print( _L("CAmrPayloadFormatWrite::ProcessFramesL CMR NO_REQ") );

                #endif

                modeReq = EAmrModeReqNone;

                }

            else

                {

                #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

                    RDebug::Print( _L("CAmrPayloadFormatWrite::ProcessFramesL CMR: %d"), frameType );

                #endif

                modeReq = static_cast<TAmrModeRequest>( frameType );

                }

            iPayloadEncoder->SetModeRequest( modeReq );

            payloadReady = iPayloadEncoder->EncodeFrame( TInt( iCurrentChannel ),

                    TAmrFrameType( frameType ), qualityInd, dataPtr );

     		#ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        		AMR_PAYLOAD_FORMAT_WRITE2 ( "CAmrPayloadFormatWrite::ProcessFramesL( ): payloadReady1 = %d ", payloadReady );

    		#endif

            // Increase current channel

            iCurrentChannel++;

            if ( iCurrentChannel == iChannels )

                {

                // All channel frames for a frame block are received

                iCurrentChannel = 0;

                }

            seekPtr += length; // update byte positions

            seekLen -= length; // update seek length

            byteIndex += length;

            iFramesEncoded++;

            }

        else

            {

            if ( frameInfo.iBitrate < 0 )

                {

                #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        		AMR_PAYLOAD_FORMAT_WRITE ( "CAmrPayloadFormatWrite::ProcessFramesL( ): frameInfo.iBitrate < 0 ");

    			#endif

                break;

                }

            else

                {

                //  No data frame

                TStreamDecoder decoder;

                decoder.Initialize( seekPtr, 0, 0 );

                decoder.Decode( 1 );                        // Skip first Padding bit

                TInt frameType = decoder.Decode( KNumValue4 );       // FT value

                if ( frameType != TInt( EAmrFrameNoData ) ) // bad frame

                    {

                    #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        				AMR_PAYLOAD_FORMAT_WRITE ( "CAmrPayloadFormatWrite::ProcessFramesL( ): bad frame ");

    				#endif

                    break;

                    }

                // QualityIndicator value

                TUint8 qualityInd = TUint8( decoder.Decode( 1 ) );

                TPtr8 dummy( 0,0,0 );

                payloadReady = iPayloadEncoder->EncodeFrame( TInt( iCurrentChannel ),

                            TAmrFrameType( frameType ), qualityInd, dummy );

                #ifdef TRACE_AMR_PAYLOAD_FORMAT_WRITE

        				AMR_PAYLOAD_FORMAT_WRITE2 ( "CAmrPayloadFormatWrite::ProcessFramesL( ): payloadReady2 = %d ", payloadReady);

    			#endif   

                // Increase current channel

                iCurrentChannel++;

                if ( iCurrentChannel == iChannels )

                    {

                    // All channel frames for a frame block are received

                    iCurrentChannel = 0;

                    }

                seekPtr++;

                seekLen--;

                byteIndex++;

                iFramesEncoded++;

                }

            }

        if ( payloadReady )

            {

            AMR_PAYLOAD_FORMAT_WRITE2( "CAmrPayloadFormatWrite::ProcessFramesL: iSinkBuffer1 = %X ", iSinkBuffer );

            AMR_PAYLOAD_FORMAT_WRITE2( "CAmrPayloadFormatWrite::ProcessFramesL: iSourceBuffer = %X ", iSourceBuffer );

    	    if ( !iSinkBuffer )

                {

                return EFalse;

                }

            // Payload has been constructed; deliver it to RTP datasink

            // Update length info of payload buffer.

            if ( seekLen < CAmrCommonUtility::FrameHeaderSize( ) 

                &&  ( iSourceBuffer->LastBuffer( ) || iNeedToFlush ) )

                {

                // No more AMR frames

                iSinkBuffer->SetLastBuffer( ETrue );    

                isDone = ETrue;

                }

            TDes8& dataDes = static_cast<CMMFDataBuffer*>( iSinkBuffer )->Data( );

            TDesC8& payloadDes = iPayloadEncoder->PayloadBuffer( );

            dataDes.SetLength( payloadDes.Length( ) );

            DeliverPacketL( *iSinkBuffer );

            }            

        }

    // If this is the last buffer, 

    // Set from datapath or by AmrPayloadFormatWrite itself

    if ( iSourceBuffer->LastBuffer( ) || iNeedToFlush ) 

        {

        AMR_PAYLOAD_FORMAT_WRITE2( "CAmrPayloadFormatWrite::ProcessFramesL: iSinkBuffer2 = %X ", iSinkBuffer );

        isDone = ETrue;

        if ( iPayloadEncoder->ReEncodeFrameL( ) )

            {

            // added for last buffer  

            // length can not be zero.

            if ( !iSinkBuffer )

                {

                return EFalse;

                }

            TDes8& dataDes = static_cast<CMMFDataBuffer*>( iSinkBuffer )->Data( );

            TDesC8& payloadDes = iPayloadEncoder->PayloadBuffer( );

            dataDes.SetLength( payloadDes.Length( ) );

            iSinkBuffer->SetLastBuffer( ETrue );   

            DeliverPacketL( *iSinkBuffer );

            }

        }

    return isDone;

    }

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

// 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() ) );

    // Construct RTP header.

    if ( !iFirstPacketFinished )

        {

        iRtpSendHeader.iMarker = 1;

        iFirstPacketFinished = ETrue;

        }

    else

        {

        iRtpSendHeader.iMarker = 0;

        }

    iRtpSendHeader.iPayloadType = iCInfo.iPayloadType;

    iRtpSendHeader.iTimestamp 

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

    if ( aPayload.BufferSize() )

        {  

        if ( iIsRtpSink )

            {

            iRtpDataSink->EmptyBufferL( &aPayload, this, iMediaId, iRtpSendHeader );

            }

        else

            {

		    aPayload.SetLastBuffer( iRtpSendHeader.iMarker );

            iClip->EmptyBufferL( &aPayload, this, iMediaId );

            }

        }

    // Reset the payload buffer as previous EmptyBufferL() is a synchronous call.

    aPayload.Data().Zero();

    iPayloadEncoder->ResetPayloadBuffer();

    }

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

// CAmrPayloadFormatWrite::EmptyBufferL

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

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