/*

* 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

*                G711 audio.

*

*/

// INCLUDE FILES

#include    "g711payloadformatread.h"

#include    "g711payloadformatdefs.h"

#include    "mccrtpdatasource.h"

#include    "mccinternaldef.h"

#include    "mccdef.h"

#include    "mccredpayloadread.h"

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

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

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

// CG711PayloadFormatRead::CG711PayloadFormatRead

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

// might leave.

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

//

CG711PayloadFormatRead::CG711PayloadFormatRead()

    {

    }

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

// CG711PayloadFormatRead::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CG711PayloadFormatRead::ConstructL( MDataSource* aSource )

    {

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

    iClip = aSource;

    iBufferToReadExists = EFalse;

    iFourCC.Set( KMccFourCCIdG711 );

    iFramesPerPacket = 1;

    // Initialize decoding state machine

    iStateMachine = CFormatDecodeStateMachine::NewL( this );

    iStateMachine->ChangeState( EDecodeIdle );

    iCurrentBuffer = EBufferOne;

    }

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

// CG711PayloadFormatRead::NewL

// Two-phased constructor.

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

//

CG711PayloadFormatRead* CG711PayloadFormatRead::NewL( MDataSource* aSource )

    {

    DP_G711_READ( "CG711PayloadFormatRead::NewL()" );

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

    CG711PayloadFormatRead* self = new (ELeave) CG711PayloadFormatRead;

    CleanupStack::PushL( self );

    self->ConstructL( aSource );

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CG711PayloadFormatRead::~CG711PayloadFormatRead()

    {

    DP_G711_READ( "CG711PayloadFormatRead::~CG711PayloadFormatRead()" );

    delete iFrameBufferOne;

    delete iFrameBufferTwo;

    if ( iSourceBufOwnership )

        {

        delete iSourceBuffer;

        }

    delete iStateMachine;

    iClip = NULL;

    iFrameArray.Close();

    }

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

// CG711PayloadFormatRead::SendDataToSinkL

// Send full frame buffer to the DataPath.

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

//

void CG711PayloadFormatRead::SendDataToSinkL()

    {

    if ( iCurrentBuffer == EBufferOne )

        {

        DP_G711_READ( "CG711PayloadFormatRead::SendDataToSinkL() - BufferOne" );

        iDataPath->BufferFilledL( iFrameBufferOne );

        iCurrentBuffer = EBufferTwo;

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

            {

            // More payload buffer is ready

            iStateMachine->ChangeState( ESourceDataReady );

            }

        }

    else

        {

        DP_G711_READ( "CG711PayloadFormatRead::SendDataToSinkL() - BufferTwo" );            

        iDataPath->BufferFilledL( iFrameBufferTwo );

        iCurrentBuffer = EBufferOne;

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

            {

            // More payload buffer is ready

            iStateMachine->ChangeState( ESourceDataReady );

            }

       }

    }

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

// CG711PayloadFormatRead::FillSinkBuffer

// Fill SinkBuffer.

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

//

void CG711PayloadFormatRead::FillSinkBufferL()

    {

    DP_G711_READ( "CG711PayloadFormatRead::FillSinkBuffer()" );

    CMMFDataBuffer* curFrameBuffer = NULL;

    if ( EBufferOne == iCurrentBuffer )

        {

        curFrameBuffer = iFrameBufferOne;

        }

    else

        {

        curFrameBuffer = iFrameBufferTwo;

        }

    TDes8& curFrameData( curFrameBuffer->Data() );

    curFrameData.SetLength( KVoIPHeaderLength );

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

    iBufferToReadExists = GetNextFrame( curFrameData );

    // G.711 Gwc expects 2 bytes for dtx-decision

    if ( iCnFrame )

        {

	    DP_G711_READ( "CG711PayloadFormatRead::FillSinkBufferL add dtx-header" );

        curFrameData[0] = KVoIPCNFrame;

        curFrameData[1] = 0;

	    }

    else

        {

	    DP_G711_READ( "CG711PayloadFormatRead::FillSinkBufferL add voice-header" );

        curFrameData[0] = KVoIPAudioFrame;

        curFrameData[1] = 0;

        }

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

	                           * TUint( iCInfo.iHwFrameTime * KDefaultSampleRateInkHz ) ) );

    DP_G711_READ2( "CG711PayloadFormatRead::FillSinkBuffer - FRAMENUM: %u",

        curFrameBuffer->FrameNumber() );

    const TInt dataLen( ( iCInfo.iHwFrameTime * KBitsPerByte )

                            + KVoIPHeaderLength );

    curFrameData.SetLength( dataLen );          

    curFrameBuffer->SetStatus( EFull );

    DP_G711_READ2( "CG711PayloadFormatRead: Filled framebuffer with buf. size: %d",

        curFrameBuffer->BufferSize() );

    iStateMachine->ChangeState( EEmptyDataToSink );

    DP_G711_READ( "CG711PayloadFormatRead::FillSinkBuffer - DONE" );

    }

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

// CG711PayloadFormatRead::FillSourceBufferL

// Send fill buffer request to the RTP Data Source.

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

//

void CG711PayloadFormatRead::FillSourceBufferL()

    {

    DP_G711_READ( "CG711PayloadFormatRead::FillSourceBufferL()");

    const TMediaId mediaId( KUidMediaTypeAudio );

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

    }

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

// CG711PayloadFormatRead::SourcePrimeL

// Prime source.

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

//

void CG711PayloadFormatRead::SourcePrimeL()

    {

    DP_G711_READ( "CG711PayloadFormatRead::SourcePrimeL()" );

    iClip->SourcePrimeL();

    }

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

// CG711PayloadFormatRead::SourcePlayL

// Start playing.

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

void CG711PayloadFormatRead::SourcePlayL()

    {

    DP_G711_READ( "CG711PayloadFormatRead::SourcePlayL()" );

    iClip->SourcePlayL();

    }

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

// CG711PayloadFormatRead::SourcePauseL

// Pause source.

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

//

void CG711PayloadFormatRead::SourcePauseL()

    {

    DP_G711_READ( "CG711PayloadFormatRead::SourcePauseL" );

    iStateMachine->Cancel();

    iStateMachine->ChangeState( EDecodeIdle );

    iFrameBufferOne->SetLastBuffer( EFalse );

    iFrameBufferTwo->SetLastBuffer( EFalse );

    iFrameBufferOne->SetStatus( EAvailable );

    iFrameBufferTwo->SetStatus( EAvailable );

    iBufferToReadExists = EFalse;

    iCurrentBuffer = EBufferOne;

    iClip->SourcePauseL();

    }

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

// CG711PayloadFormatRead::SourceStopL

// Stop source

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

//

void CG711PayloadFormatRead::SourceStopL()

    {

    DP_G711_READ( "CG711PayloadFormatRead::SourceStopL" );

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

    }

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

// CG711PayloadFormatRead::BufferFilledL

// 

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

//

void CG711PayloadFormatRead::DataBufferFilledL( CMMFBuffer* aBuffer,

    const TRtpRecvHeader& aRecvHeader )

    {

    DP_G711_READ2( "CG711PayloadFormatRead::DataBufferFilledL iTimestamp: %u",

        aRecvHeader.iTimestamp )

    DP_G711_READ2( "CG711PayloadFormatRead::DataBufferFilledL this: 0x%x", this )

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

        }

    TInt numOfFrames = DecodePayload( iSourceBuffer->Data() );

    // Whenever BufferFilledL is called from RtpSourceSink

    // Set the state machine to fillsinkbuffer

    if ( numOfFrames )

        {

        iBufferToReadExists = ETrue;

        iSourceBuffer->SetFrameNumber( iRecvHeader.iTimestamp );

        iStateMachine->ChangeState( ESourceDataReady );

        }

    else

        {

        DP_G711_READ( "CG711PayloadFormatRead::BufferFilledL, decode failed" )

        FillSourceBufferL();

        }

    }

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

// CG711PayloadFormatRead::SampleRate

// Returns samplerate.

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

//

TUint CG711PayloadFormatRead::SampleRate()

    {

    return KDefaultSampleRate;

    }  

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

// CG711PayloadFormatRead::SetSampleRate

// Set samplerate.

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

//

TInt CG711PayloadFormatRead::SetSampleRate( TUint aSampleRate )

    {

    if ( KDefaultSampleRate != aSampleRate )

        {

        return KErrNotSupported;

        }

    else

        {

        return KErrNone;

        }

    }

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

// CG711PayloadFormatRead::NumChannels

// Returns number of channels.

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

//

TUint CG711PayloadFormatRead::NumChannels()

    {

    return KMono;

    }

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

// CG711PayloadFormatRead::SourceThreadLogoff

// Logout the source thread.

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

//

void CG711PayloadFormatRead::SourceThreadLogoff()

    {

    iClip->SourceThreadLogoff();

    }

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

// CG711PayloadFormatRead::NegotiateSourceL

// Negotiate Source.

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

//

void CG711PayloadFormatRead::NegotiateSourceL( MDataSink& aDataSink )

    {

    DP_G711_READ( "CG711PayloadFormatRead::NegotiateSourceL()" ) ;

    iDataPath = &aDataSink;

    iClip->NegotiateSourceL( *this );

    }

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

// CG711PayloadFormatRead::SourceThreadLogon

// Logon to the source thread.

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

//

TInt CG711PayloadFormatRead::SourceThreadLogon( MAsyncEventHandler& aEventHandler )

    {

    if ( iClip )

        {

        iClip->SourceThreadLogon( aEventHandler );

        return KErrNone;

        }

    else

        {

        return KErrNotReady;

        }

    }

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

// CG711PayloadFormatRead::SetSourceDataTypeCode

// Sets source datatype fourCC code

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

//

TInt CG711PayloadFormatRead::SetSourceDataTypeCode( TFourCC aSourceFourCC,

                                                    TMediaId aMediaId )

    {

    DP_G711_READ( "CG711PayloadFormatRead::SetSourceDataTypeCode()" );

    if ( KUidMediaTypeAudio != aMediaId.iMediaType ) 

        {

        return KErrNotSupported;

        }

    iFourCC = aSourceFourCC;

    iClip->SetSourceDataTypeCode( iFourCC, aMediaId );

    return KErrNone;

    }

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

// CG711PayloadFormatRead::SourceDataTypeCode

// Returns the current datatype FourCC code.

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

//

TFourCC CG711PayloadFormatRead::SourceDataTypeCode( TMediaId aMediaId )

    {

    if ( KUidMediaTypeAudio == aMediaId.iMediaType )

        {

        return iFourCC;

        }

    else

        {

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

        }

    }

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

// CG711PayloadFormatRead::SinkDataTypeCode

// Returns the current datatype FourCC code.

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

//

TFourCC CG711PayloadFormatRead::SinkDataTypeCode( TMediaId aMediaId )

    {

    if ( KUidMediaTypeAudio == aMediaId.iMediaType )

        {

        return iFourCC;

        }

    else

        {

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

        }

    }

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

// CG711PayloadFormatRead::CreateSourceBufferL

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

// buffer is created.

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

//

CMMFBuffer* CG711PayloadFormatRead::CreateSourceBufferL( TMediaId aMediaId,

                                                         TBool &aReference )

    {

    if ( KUidMediaTypeAudio != aMediaId.iMediaType )

        {

        User::Leave( KErrNotSupported );

        }

    // The source buffers belong to G711PayloadFormatRead not to datapath

    // aference should be set to ETrue and destroyed by G711PayloadFormatRead itself.

    aReference = ETrue;

    return iFrameBufferOne; 

    }

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

// CG711PayloadFormatRead::CreateSourceBufferL

// Create a source buffer for the given media, setting frame size to match

// the given sink buffer.

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

CMMFBuffer* CG711PayloadFormatRead::CreateSourceBufferL( TMediaId aMediaId,

                                                        CMMFBuffer& /*aSinkBuffer*/,

                                                        TBool& aReference )

    {

    if ( KUidMediaTypeAudio != aMediaId.iMediaType )

        {

        User::Leave( KErrNotSupported );

        }

    return CreateSourceBufferL( aMediaId, aReference );

    }

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

// CG711PayloadFormatRead::FillBufferL

// Fill Buffer.

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

//

void CG711PayloadFormatRead::FillBufferL( CMMFBuffer* aBuffer, 

                                          MDataSink* aConsumer, 

                                          TMediaId aMediaId )

    {

    if ( NULL == aBuffer ) 

        {

        User::Leave( KErrGeneral );

        }

    DP_G711_READ3( 

    "CG711PayloadFormatRead::FillBufferL() buffer 0x%x passed in with length %d bytes",

    aBuffer, aBuffer->BufferSize() );

    if ( KUidMediaTypeAudio != aMediaId.iMediaType )

        {

        User::Leave( KErrNotSupported );

        }

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