/*

* Copyright (c) 2004-2008 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 component capable to read RTP payload containing

*                ILBC audio.

*

*/

// INCLUDE FILES

#include    "ilbcpayloadformatread.h"

#include    "mccrtpdatasource.h"

#include    "ilbcpayloadformatutil.h"

#include    "mccinternaldef.h"

#include    "mccdef.h"

#include    "mccredpayloadread.h"

// MACROS

#ifdef _DEBUG

#define TRACE_ILBC_PAYLOAD_FORMAT_READ

#endif

// FORWARD DECLARATIONS

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

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

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

// CIlbcPayloadFormatRead::CIlbcPayloadFormatRead

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

// might leave.

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

//

CIlbcPayloadFormatRead::CIlbcPayloadFormatRead () : 

        iMediaId( KUidMediaTypeAudio )

    {

    };

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

// CIlbcPayloadFormatRead::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIlbcPayloadFormatRead::ConstructL( MDataSource* aSource )

    {

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

    iClip = aSource;

    iBufferToReadExists = EFalse;

    iFourCC.Set( KMccFourCCIdILBC );

    // Initialize decoding state machine

    iStateMachine = CFormatDecodeStateMachine::NewL( this );

    iStateMachine->ChangeState( EDecodeIdle );

    iCurrentBuffer = EBufferOne;

    }

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

// CIlbcPayloadFormatRead::NewL

// Two-phased constructor.

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

//

CIlbcPayloadFormatRead* CIlbcPayloadFormatRead::NewL( MDataSource* aSource )

    {

    #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

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

    #endif

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

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

    CleanupStack::PushL( self );

    self->ConstructL( aSource );

    CleanupStack::Pop( self );

    return self;

    };

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

// CIlbcPayloadFormatRead::~CIlbcPayloadFormatRead()

// Destructor.

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

//

CIlbcPayloadFormatRead::~CIlbcPayloadFormatRead()

    {

    #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

        RDebug::Print( _L("CIlbcPayloadFormatRead::~CIlbcPayloadFormatRead") );

    #endif

    delete iFrameBufferOne;

    delete iFrameBufferTwo;

    if ( iSourceBufOwnership )

        {

        delete iSourceBuffer;

        }

    else

        {

        iSourceBuffer = NULL;

        }

    delete iStateMachine;

    iClip = NULL;

	iFrameArray.Close();

    };

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

// CIlbcPayloadFormatRead::SendDataToSinkL

// Send full frame buffer to DataPath.

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

//

void CIlbcPayloadFormatRead::SendDataToSinkL()

    {

    if ( iCurrentBuffer == EBufferOne )

        {

        #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

            RDebug::Print( _L( "CIlbcPayloadFormatRead::SendDataToSinkL - BufferOne") );

        #endif

        iDataPath->BufferFilledL( iFrameBufferOne );

        iCurrentBuffer = EBufferTwo;

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

            {

            // More payload buffer is ready

            iStateMachine->ChangeState( ESourceDataReady );

            }

        }

    else

        {

        #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

            RDebug::Print( _L( "CIlbcPayloadFormatRead::SendDataToSinkL - BufferTwo") );

        #endif

        iDataPath->BufferFilledL( iFrameBufferTwo );

        iCurrentBuffer = EBufferOne;

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

            {

            // More payload buffer is ready

            iStateMachine->ChangeState( ESourceDataReady );

            }

        }

    }

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

// CIlbcPayloadFormatRead::FillSinkBuffer

// Fill SinkBuffer.

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

//

void CIlbcPayloadFormatRead::FillSinkBufferL()

    {

    #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

        RDebug::Print( _L( "CIlbcPayloadFormatRead::FillSinkBuffer" ) );

    #endif

    CMMFDataBuffer* curFrameBuffer;

    if ( EBufferOne == iCurrentBuffer )

        {

        #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

            RDebug::Print( _L( "IlbcPayloadFormatRead: Filling EBufferOne reqsize: %d"),

                iFrameBufferOne->RequestSize() );

        #endif

        curFrameBuffer = iFrameBufferOne;

        }

    else

        {

        #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

            RDebug::Print( _L("IlbcPayloadFormatRead: Filling EBufferTwo reqsize: %d"),

                iFrameBufferTwo->RequestSize() );

        #endif

        curFrameBuffer = iFrameBufferTwo;

        }

    TDes8& dataDes = curFrameBuffer->Data();

    dataDes.Zero();

    dataDes.SetLength( KiLBCNumOfHeaderBytes );

    // Put next frame decoded from RTP payload to the framebuffer

    iBufferToReadExists = GetNextFrame( dataDes );

    if ( iCnFrame )

        {

        #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

            RDebug::Print( _L ("CIlbcPayloadFormatRead::FillSinkBuffer - ADD CNOISE FRAME HEADER") );

        #endif

        dataDes[0] = KCNoiseFrameHeaderByte;

        dataDes[1] = 0;

        }

    else

        {

        #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

            RDebug::Print( _L ("CIlbcPayloadFormatRead::FillSinkBuffer - ADD AUDIO FRAME HEADER") );

        #endif        

        dataDes[0] = KAudioFrameHeaderByte;

        dataDes[1] = 0;

        }

    curFrameBuffer->SetFrameNumber( iRecvHeader.iTimestamp + ( ( iFrameIndex - 1 )

                                    * TUint( iCInfo.iHwFrameTime * KiLBCSampleRate * 0.001 ) ) );

    if ( KIlbcMode20msFrame == iCInfo.iCodecMode  )

        {

        dataDes.SetLength( KiLBCFrameSize20ms + KiLBCNumOfHeaderBytes );

        }

    else if( KIlbcMode30msFrame == iCInfo.iCodecMode )

        {

        dataDes.SetLength( KiLBCFrameSize30ms + KiLBCNumOfHeaderBytes );

        }

    else

        {

        // Make PC-LINT happy

        }        

    curFrameBuffer->SetStatus( EFull );

    iStateMachine->ChangeState( EEmptyDataToSink );

    #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

        RDebug::Print( _L ("CIlbcPayloadFormatRead::FillSinkBuffer - DONE") );

    #endif

    }

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

// CIlbcPayloadFormatRead::FillSourceBufferL

// Send fill buffer request to RTP Data Source.

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

//

void CIlbcPayloadFormatRead::FillSourceBufferL()

    {

    #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

        RDebug::Print ( _L("CIlbcPayloadFormatRead::FillSourceBufferL") );

    #endif

    // RtpSourceSink doesn't really need the Media Id.        

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

    }

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

// CIlbcPayloadFormatRead::SourcePrimeL

// Prime source.

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

//

void CIlbcPayloadFormatRead::SourcePrimeL()

    {

    #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

        RDebug::Print (_L ("CIlbcPayloadFormatRead::SourcePrimeL()"));

    #endif

    iClip->SourcePrimeL();

    }

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

// CIlbcPayloadFormatRead::SourcePlayL

// Start playing.

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

//

void CIlbcPayloadFormatRead::SourcePlayL()

    {

    #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

        RDebug::Print (_L ("CIlbcPayloadFormatRead::SourcePlayL()"));

    #endif

    iClip->SourcePlayL();

    }

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

// CIlbcPayloadFormatRead::SourcePauseL

// Pause source.

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

//

void CIlbcPayloadFormatRead::SourcePauseL()

    {

    #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

        RDebug::Print( _L("CIlbcPayloadFormatRead::SourcePauseL") );

    #endif

    iStateMachine->Cancel();

    iStateMachine->ChangeState( EDecodeIdle );

    iFrameBufferOne->SetLastBuffer( EFalse );

    iFrameBufferTwo->SetLastBuffer( EFalse );

    iFrameBufferOne->SetStatus( EAvailable );

    iFrameBufferTwo->SetStatus( EAvailable );

    iBufferToReadExists = EFalse;

    iCurrentBuffer = EBufferOne;

    iClip->SourcePauseL();

    }

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

// CIlbcPayloadFormatRead::SourceStopL

// Stop source.

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

//

void CIlbcPayloadFormatRead::SourceStopL()

    {

    #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

        RDebug::Print( _L("CIlbcPayloadFormatRead::SourceStopL") );

    #endif

    // DO NOT RESET PACKET COUNT BACK TO ZERO HERE

    // UPPER LAYER MAY CALL LastDlPacketCount LATER

    iStateMachine->Cancel();

    iStateMachine->ChangeState( EDecodeIdle );

    iFrameBufferOne->SetLastBuffer( EFalse );

    iFrameBufferTwo->SetLastBuffer( EFalse );

    iFrameBufferOne->SetStatus( EAvailable );

    iFrameBufferTwo->SetStatus( EAvailable );

    iBufferToReadExists = EFalse;

    iCurrentBuffer = EBufferOne;

    iClip->SourceStopL();

    }

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

// CIlbcPayloadFormatRead::BufferFilledL

// RTP data source has filled buffer.

// NOTE: Although redundancy is negotiated, sender may deside to send audio 

// packets without redundancy (RFC2198, ch5).

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

//

void CIlbcPayloadFormatRead::DataBufferFilledL( CMMFBuffer* aBuffer,

                                            const TRtpRecvHeader& aRecvHeader )

    {

    #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

        RDebug::Print (_L ("CIlbcPayloadFormatRead::DataBufferFilledL - TSTAMP: %u"),

            aRecvHeader.iTimestamp );

    #endif

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

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

        User::Leave( KErrNotSupported ) );

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

    iRecvHeader = aRecvHeader;

    if ( KComfortNoisePT == iRecvHeader.iPayloadType 

        || KOldComfortNoisePT == iRecvHeader.iPayloadType )

        {

        iCnFrame = ETrue;

        }

    else 

        {

        iCnFrame = EFalse;

        }

    iNumOfFrames = DecodePayload( iSourceBuffer->Data() );

    // Whenever BufferFilledL is called from RtpSourceSink

    // Set the state machine to fillsinkbuffer

    if ( iNumOfFrames )

        {

        iBufferToReadExists = ETrue;

        iSourceBuffer->SetFrameNumber( iRecvHeader.iTimestamp );

        iStateMachine->ChangeState( ESourceDataReady );

        }

    else

        {

        #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

        RDebug::Print ( _L("CIlbcPayloadFormatRead::BufferFilledL, decode failed" ) );

        #endif

        FillSourceBufferL();

        }

    }

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

// CIlbcPayloadFormatRead::SampleRate

// Returns samplerate.

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

//

TUint CIlbcPayloadFormatRead::SampleRate()

    {

    return KiLBCSampleRate;

    }  

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

// CIlbcPayloadFormatRead::SetSampleRate

// Set samplerate.

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

//

TInt CIlbcPayloadFormatRead::SetSampleRate( TUint aSampleRate )

    {

    return ( KiLBCSampleRate == aSampleRate ) ? KErrNone : KErrNotSupported;

    }

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

// CIlbcPayloadFormatRead::NumChannels

// Returns number of channels.

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

//

TUint CIlbcPayloadFormatRead::NumChannels()

    {

    return KMono;

    }

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

// CIlbcPayloadFormatRead::SourceThreadLogoff

// Logout the source thread.

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

//

void CIlbcPayloadFormatRead::SourceThreadLogoff()

    {

    iClip->SourceThreadLogoff();

    }

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

// CIlbcPayloadFormatRead::NegotiateSourceL

// Negotiate Source. Not used.

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

//

void CIlbcPayloadFormatRead::NegotiateSourceL( MDataSink& aDataSink )

    {

    iSink = &aDataSink;

    iClip->NegotiateSourceL( *this );

    }

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

// CIlbcPayloadFormatRead::SourceThreadLogon

// Logon the source thread.

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

//

TInt CIlbcPayloadFormatRead::SourceThreadLogon(

                                        MAsyncEventHandler& aEventHandler

                                        )

    {

    if ( iClip )

        {

        iClip->SourceThreadLogon( aEventHandler );

		return KErrNone;

        }

    else

        {

        return KErrNotReady;

        }        

    }

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

// CIlbcPayloadFormatRead::SetSourceDataTypeCode

// Sets source datatype fourCC code.

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

//

TInt CIlbcPayloadFormatRead::SetSourceDataTypeCode( TFourCC aSourceFourCC,

    TMediaId aMediaId )

    {

    #ifdef TRACE_ILBC_PAYLOAD_FORMAT_READ

        RDebug::Print (_L ("CIlbcPayloadFormatRead::SetSourceDataTypeCode()"));

    #endif

    if ( KUidMediaTypeAudio != aMediaId.iMediaType ) 

        {

        return KErrNotSupported;

        }

    iFourCC = aSourceFourCC;

    iMediaId = aMediaId;

    iClip->SetSourceDataTypeCode( iFourCC, aMediaId );

    return KErrNone;

    }

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

// CIlbcPayloadFormatRead::SourceDataTypeCode

// Returns the current datatype FourCC code.

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

//

TFourCC CIlbcPayloadFormatRead::SourceDataTypeCode( TMediaId aMediaId )

    {

    if ( KUidMediaTypeAudio == aMediaId.iMediaType )

        {

        return iFourCC;

        }

    else

        {

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

        }

    }

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

// CIlbcPayloadFormatRead::SinkDataTypeCode

// Returns the current datatype FourCC code.

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

//

TFourCC CIlbcPayloadFormatRead::SinkDataTypeCode( TMediaId aMediaId )

    {

    if ( KUidMediaTypeAudio == aMediaId.iMediaType )

        {

        return iFourCC;

        }

    else

        {

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

        }

    }

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

// CIlbcPayloadFormatRead::CreateSourceBufferL

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

// if buffer is created.

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

//

CMMFBuffer* CIlbcPayloadFormatRead::CreateSourceBufferL( TMediaId aMediaId,

    TBool &aReference )

    {

    if ( KUidMediaTypeAudio != aMediaId.iMediaType )

        {