/*

* 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:    PayloadFormat plugin capable to read RTP payload containing

*                AMR audio.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <mmf/common/mmffourcc.h>

#include "amrpayloadformatread.h"

#include "amrpayloadencoder.h"

#include "amrpayloaddecoder.h"

#include "amrpayloaddecoderoa.h"

#include "amrpayloadformatutil.h"

#include "amrcommonutil.h"

#include "mccrtpdatasource.h"

#include "mccuids.hrh"

#include "mccinternaldef.h"

#include "amrpayloadformatter.h"

#include "mccredpayloadread.h"

#ifdef VOIP_TRACE_ENABLED

#include <voip_trace.h>

#endif

// CONSTANTS

const TReal KTimeMultiplier = 0.001;

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

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

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

// CAmrPayloadFormatRead::CAmrPayloadFormatRead

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

// might leave.

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

//

CAmrPayloadFormatRead::CAmrPayloadFormatRead ( ) :

    iIsNb( ETrue ), iSamplingRate( KAmrNbSampleRate ), iChannels( 1 ),

    iMode( EAmrFrame12_2 ), iCmr ( EAmrModeReq7 ), iStreamEncoder( TStreamEncoder() )

    {

    }

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

// CAmrPayloadFormatRead::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAmrPayloadFormatRead::ConstructL ( MDataSource* aSource )

    {

    User::LeaveIfNull( aSource );

    iRtpDataSource = aSource;

    iClip = aSource;

    iBufferToReadExists = EFalse;

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

    // Set default value of iChannels and iFramesPerPacket

    iFramesPerPacket = 1;

    iChannels = 1;

    // Initialize decoding state machine

    iStateMachine = CFormatDecodeStateMachine::NewL( this );

    iStateMachine->ChangeState( EDecodeIdle );

    iCurrentBuffer = EBufferOne;

    #ifdef FTD_ENABLED

    User::LeaveIfError( iJBufStatsQueue.OpenGlobal( KMccJBufferStats, 

        EOwnerProcess ) );    

    #endif        

    }

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

// CAmrPayloadFormatRead::NewL

//

// Two-phased constructor.

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

//

CAmrPayloadFormatRead* CAmrPayloadFormatRead::NewL ( MDataSource* aSource )

    {

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

    AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::NewL" );

    CAmrPayloadFormatRead* self = new ( ELeave ) CAmrPayloadFormatRead;

    CleanupStack::PushL ( self );

    self->ConstructL ( aSource );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAmrPayloadFormatRead::~CAmrPayloadFormatRead

//

// Destructor.

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

//

CAmrPayloadFormatRead::~CAmrPayloadFormatRead ( )

    {

    // commented out CreateSourceBufferL now sets aReference to ETrue.

    // datapath doesn't clean this buffer any longer.

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

    	AMR_PAYLOAD_FORMAT_READ2 ( "CAmrPayloadFormatRead::~CAmrPayloadFormatRead: 0x%x", this );

    	AMR_PAYLOAD_FORMAT_READ2 ( "CAmrPayloadFormatRead::~CAmrPayloadFormatRead iFrameBufferOne: 0x%x", iFrameBufferOne );

    	AMR_PAYLOAD_FORMAT_READ2 ( "CAmrPayloadFormatRead::~CAmrPayloadFormatRead iFrameBufferTwo: 0x%x", iFrameBufferTwo );

    	AMR_PAYLOAD_FORMAT_READ2 ( "CAmrPayloadFormatRead::~CAmrPayloadFormatRead iSourceBuffer: 0x%x", iSourceBuffer );

    	AMR_PAYLOAD_FORMAT_READ2 ( "CAmrPayloadFormatRead::~CAmrPayloadFormatRead iStateMachine: 0x%x", iStateMachine );

    	AMR_PAYLOAD_FORMAT_READ2 ( "CAmrPayloadFormatRead::~CAmrPayloadFormatRead iPayloadDecoder: 0x%x", iPayloadDecoder );

    	AMR_PAYLOAD_FORMAT_READ2 ( "CAmrPayloadFormatRead::~CAmrPayloadFormatRead iRtpDataSource: 0x%x", iRtpDataSource );

    	AMR_PAYLOAD_FORMAT_READ2 ( "CAmrPayloadFormatRead::~CAmrPayloadFormatRead iClip: 0x%x", iClip );

    	AMR_PAYLOAD_FORMAT_READ2 ( "CAmrPayloadFormatRead::~CAmrPayloadFormatRead iDataPath: 0x%x", iDataPath );

    	AMR_PAYLOAD_FORMAT_READ2 ( "CAmrPayloadFormatRead::~CAmrPayloadFormatRead iBufferToRead: 0x%x", iBufferToRead );

    #endif

    delete iFrameBufferOne;

    delete iFrameBufferTwo;

    if ( iSourceBufOwnership )

        {

        delete iSourceBuffer;

        }

    iSourceBuffer = NULL;

    if ( iStateMachine )

        {

        iStateMachine->Cancel( );

        delete iStateMachine;

        }

    delete iPayloadDecoder;

    iRtpDataSource = NULL;

    iClip = NULL;

    iDataPath = NULL;

    iBufferToRead = NULL;

    iEventHandler = NULL;

    #ifdef FTD_ENABLED

    iJBufStatsQueue.Close();

    #endif

    }

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

// CAmrPayloadFormatRead::Streams

// Return number of audio streams for the given media

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

//

TUint CAmrPayloadFormatRead::Streams( TUid aMediaType ) const

    {

    if ( KUidMediaTypeAudio == aMediaType )

        {

        return 1;

        }

    else

        {

        return 0;

        }

    }

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

// CAmrPayloadFormatRead::FrameTimeInterval

// Return the frame time interval for the given media

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

//

TTimeIntervalMicroSeconds CAmrPayloadFormatRead::FrameTimeInterval( 

        TMediaId aMediaId ) const

    {

    if ( KUidMediaTypeAudio == aMediaId.iMediaType )

        {

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

        return TTimeIntervalMicroSeconds( TInt64( hwFrametime ) );

        }

    else

        {

        return TTimeIntervalMicroSeconds( TInt64( 0 ) );

        }

    }

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

// CAmrPayloadFormatRead::FillBufferL

// Fill Buffer

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

//

void CAmrPayloadFormatRead::FillBufferL( CMMFBuffer* aBuffer, 

        MDataSink* aConsumer, TMediaId aMediaId )

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

    	AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::FillBufferL( )" );

    #endif

    User::LeaveIfNull( aBuffer );

    User::LeaveIfNull( aConsumer );

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

    	AMR_PAYLOAD_FORMAT_READ3 ( "CAmrPayloadFormatRead::FillBufferL( ) buffer 0x%x passed in with length %d bytes \n", aBuffer, aBuffer->BufferSize( ) );

    #endif

    #ifdef VOIP_TRACE_ENABLED

        VoipTrace( "%x %x %x %x", MCC_TRACE, MCC_AMR_PLF_READ_FILLBUFFERL,

            aBuffer, aConsumer );

    #endif

    if ( KUidMediaTypeAudio != aMediaId.iMediaType )

        {

        User::Leave( KErrNotSupported );

        }

    if ( KUidMmfDataBuffer != aBuffer->Type( ) )

        {

        User::Leave( KErrNotSupported );

        }

    iDataPath = aConsumer;

    iMediaId = aMediaId;

    // aBuffer is a reference to those frame buffers that AmrPayloadFormatRead owns

    aBuffer->SetLastBuffer( EFalse );

    iFillRequested = ETrue;

    if ( iCurrentBuffer == EBufferOne )

        {

        iFrameBufferTwo->SetStatus( EAvailable );

        }

    else

        {

        iFrameBufferOne->SetStatus( EAvailable );

        }

    if ( iBufferToReadExists ) // Payload has some frames not decoded

        {

        iStateMachine->ChangeState( ESourceDataReady );

        }

    else

        {

        #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ 

        	AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::FillBufferL( ), Request data from source\n" );

        #endif

        FillSourceBufferL(); // No payload ask for it

        } 

    }

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

// CAmrPayloadFormatRead::DoRead

// Reads data starting from the given position into the source buffer 

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

//

TBool CAmrPayloadFormatRead::DoRead( CMMFBuffer* aBuffer )

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

        AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::DoRead" );

    #endif

    #ifdef VOIP_MCC_DL_TRACE_ENABLED

        VoipTrace( "%x %x %x", MCC_TRACE, MCC_AMR_PLF_READ_DOREAD, aBuffer );

    #endif

    if ( !aBuffer )

        {

        return EFalse;

        }

    if ( EFull == aBuffer->Status( ) )

        {

        #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

        RDebug::Print ( _L ( "CAmrPayloadFormatRead::DoRead - Buffer already full" ) );

        #endif

        return EFalse;

        }

    if ( iNumOfFrames == 0 )

        {

        return EFalse;

        }

    TAmrFrame* frames = iPayloadDecoder->Frames( );

    TDes8& bufferDes = static_cast<CMMFDataBuffer*>( aBuffer )->Data();

    TInt byteIndex = bufferDes.Length( );

    TUint8* desPtr = const_cast<TUint8*>( bufferDes.Ptr( ) );

    iStreamEncoder.Initialize( desPtr, byteIndex, 0 );

   	#ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

    	AMR_PAYLOAD_FORMAT_READ2 ( "CAmrPayloadFormatRead::DoRead - iCurrentFrame = %d",

    	iCurrentFrame );

    #endif

    TInt bitCount = iPayloadDecoder->SpeechBitCount( frames[iCurrentFrame].iFrameType );

    // Calculate byte count

    TInt nextFrameLen =

    	bitCount % TInt(KNumValue8) == 0 ? bitCount / TInt(KNumValue8) : bitCount / TInt(KNumValue8) + 1;

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

    	AMR_PAYLOAD_FORMAT_READ4 ( "CAmrPayloadFormatRead::DoRead - iCurrentFrame = %d iNumOfFrames = %d byteIndex = %d",

        	iCurrentFrame, iNumOfFrames, byteIndex );

    #endif

    // Construct 8-bit frame header.

    // +-+-+-+-+-+-+-+-+

    // |P|  FT   |Q|P|P|

    // +-+-+-+-+-+-+-+-+

    iStreamEncoder.Encode( 0, 1 );

    iStreamEncoder.Encode( TInt( frames[iCurrentFrame].iFrameType ), KNumValue4 );

    iStreamEncoder.Encode( frames[iCurrentFrame].iFrameQualityInd, 1 );

    iStreamEncoder.Encode( 0, KNumValue2 );

    if ( bitCount > 0 )

        {

        // Construct core frame part ( speech data )

        iStreamEncoder.Encode( frames[iCurrentFrame].iFrameData, 0, 

                               frames[iCurrentFrame].iBitIndex, bitCount );

        if ( iStreamEncoder.BitIndex( ) != 0 )

            {

            // Need padding to byte boundray

            iStreamEncoder.Encode( 0, KNumValue8 - iStreamEncoder.BitIndex( ) );

            }

        }

    // Update iCurrentFrame

    iCurrentFrame++;

    byteIndex = byteIndex + nextFrameLen + 1;       // Add 1 for frame header byte

    // Get next frame length

    if ( iCurrentFrame < iNumOfFrames )

        {

        bitCount = iPayloadDecoder->SpeechBitCount( frames[iCurrentFrame].iFrameType );

        // Calculate byte count

        nextFrameLen =

        	bitCount % (TInt) KNumValue8 == 0 ? bitCount / (TInt) KNumValue8 : bitCount / (TInt) KNumValue8 + 1;

        }

    bufferDes.SetLength( byteIndex );

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

    	AMR_PAYLOAD_FORMAT_READ4 ( "CAmrPayloadFormatRead::DoRead - after decoding iCurrentFrame = %d iNumOfFrames = %d byteIndex = %d",

        iCurrentFrame, iNumOfFrames, byteIndex );

    #endif

    if ( iCurrentFrame == iNumOfFrames )

        {

        // Packet is fully decoded.

        // If it is the last buffer from RtpSourceSink, then we are not

        // expecting more packets. Also SetLastBuffer to notify datapath.

        if( iBufferToRead->LastBuffer( ) )

            {

            aBuffer->SetLastBuffer( ETrue );

            aBuffer->SetStatus( EFull );

            }

        return ETrue;

        }

    return EFalse;

    }

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

// CAmrPayloadFormatRead::FillSinkBufferL

// Read RTP payload and convert it into AMR frames.

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

//

void CAmrPayloadFormatRead::FillSinkBufferL( )

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

        AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::FillSinkBuffer( )" );

    #endif

    #ifdef VOIP_MCC_DL_TRACE_ENABLED

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

    #endif    

    CMMFBuffer* curBuffer;

    if ( EBufferOne == iCurrentBuffer )

        {

        curBuffer = iFrameBufferOne;

        #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

        AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::FillSinkBuffer( ) - Current Buffer One" );

        #endif

        }

    else

        {

        curBuffer = iFrameBufferTwo;

        #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

        AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::FillSinkBuffer( ) - Current Buffer Two" );

        #endif

        }

	curBuffer->SetStatus( EAvailable );

    TBool allFrmBuffered = DoRead( curBuffer );

	curBuffer->SetFrameNumber(

		iRecvHeader.iTimestamp + ( ( iCurrentFrame - 1 )

	    * TUint( iCInfo.iHwFrameTime * iSamplingRate * KTimeMultiplier ) ) );

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

    AMR_PAYLOAD_FORMAT_READ2 ( "CAmrPayloadFormatRead::FillSinkBuffer - FRAMENUM: %u",

        curBuffer->FrameNumber() );

    #endif	                           

    // Do not wait for the buffer to be filled up. If we do, this will cause jitters in

    // comfort-noise ( SID frame ) playing since SID-frame packets take considerably less

    // data bytes and it will delay waiting for many SID-frame packets before forwarding them to 

    // DataPath for further play-out processing.

    // Instead, forward the data as soon as we receive and decode one packet

    // to avoid jitters in play-out.

    if ( allFrmBuffered )

        {   

        iBufferToReadExists = EFalse;

        }

    // Do not forward zero length buffers

    if ( curBuffer->BufferSize() > 0 )

        {

        iStateMachine->ChangeState( EEmptyDataToSink );

        }

    else

        {

        #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ 

        	AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::FillSinkBufferL( ), Request data from source\n" );

        #endif

        FillSourceBufferL(); // No payload ask for it                           

        }

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

   	AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::FillSinkBuffer - DONE" );

    #endif

    }

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

// CAmrPayloadFormatRead::FillSourceBufferL

// Send fill buffer request to RTP Data Source

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

//

void CAmrPayloadFormatRead::FillSourceBufferL( )

    {

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

        AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::FillSourceBufferL( )" );

    #endif 

    iClip->FillBufferL(iSourceBuffer, this, iMediaId );     

    }

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

// CAmrPayloadFormatRead::SendDataToSinkL

// Send full frame buffer to Data Path

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

//

void CAmrPayloadFormatRead::SendDataToSinkL( )

    {

    #ifdef VOIP_MCC_DL_TRACE_ENABLED

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

    #endif

    iFillRequested = EFalse;

    if ( EBufferOne == iCurrentBuffer )

        {

        #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

        AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::SendDataToSinkL( ) - BufferOne"  );

        #endif

        iDataPath->BufferFilledL( iFrameBufferOne );

        iCurrentBuffer = EBufferTwo;

        if ( iBufferToReadExists && !iFrameBufferOne->LastBuffer( ) )

            {

            // More payload buffer is needed

            iStateMachine->ChangeState( ESourceDataReady );

            }

        }

    else

        {

        #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

        AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::SendDataToSinkL( ) - BufferTwo" );

        #endif

        iDataPath->BufferFilledL( iFrameBufferTwo );

        iCurrentBuffer = EBufferOne;

        if ( iBufferToReadExists && !iFrameBufferTwo->LastBuffer( ) )

            {

            // More payload buffer is needed

            iStateMachine->ChangeState( ESourceDataReady );

            }

       }

    #ifdef TRACE_AMR_PAYLOAD_FORMAT_READ

    AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::SendDataToSinkL( ) - DONE" );

    #endif

    }

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

// CAmrPayloadFormatRead::CreateSourceBufferL

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

// buffer is created.

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

//

CMMFBuffer* CAmrPayloadFormatRead::CreateSourceBufferL( TMediaId aMediaId, 

        TBool &aReference )

    {

    #ifdef VOIP_TRACE_ENABLED

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

    #endif

    if ( KUidMediaTypeAudio != aMediaId.iMediaType )

        {

        User::Leave( KErrNotSupported );

        }

    // the source buffers belong to AmrPayloadFormatRead not to datapath