/*
* Copyright (c) 2005-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:    Implements format decode interface for redundancy plugin.
*
*/





// INCLUDE FILES
#include "rtpheader.h"
#include "mccredpayloadread.h"
#include "mccreddecoder.h"
#include "mccredpayloadformatdefs.h"
#include "formatstatemachine.h"

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

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

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::CMccRedPayloadRead
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CMccRedPayloadRead::CMccRedPayloadRead()
    {
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CMccRedPayloadRead::ConstructL( MDataSource* aSource )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::ConstructL" )
    __ASSERT_ALWAYS( aSource, User::Leave( KErrArgument ) );
    
    iClip = aSource;
    iRedDecoder = CMccRedDecoder::NewL();
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CMccRedPayloadRead* CMccRedPayloadRead::NewL( MDataSource* aSource )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::NewL" )
    __ASSERT_ALWAYS( aSource, User::Leave( KErrArgument ) );
    
    CMccRedPayloadRead* self = new( ELeave ) CMccRedPayloadRead;
    
    CleanupStack::PushL( self );
    self->ConstructL( aSource );
    CleanupStack::Pop( self );

    return self;
    }

    
// Destructor
CMccRedPayloadRead::~CMccRedPayloadRead()
    {
    DP_RED_DECODE( "CMccRedPayloadRead::~CMccRedPayloadRead" )

    delete iRedDecoder;
    if ( iSourceBufOwnership )
        {
        delete iSourceBuffer;
        }
    else
        {
        iSourceBuffer = NULL;
        }
    
    iDataSink = NULL;
    iClip = NULL;
    iSinkBuffer = NULL;
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::ConfigurePayloadFormatL
// Configure payload decoding parameters.
// -----------------------------------------------------------------------------
//
void CMccRedPayloadRead::ConfigurePayloadFormatL( const TDesC8& aConfigParams )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::ConfigurePayloadFormatL" )
    __ASSERT_ALWAYS( aConfigParams.Size() == sizeof( TMccRedPayloadReadConfig ),
        User::Leave( KErrArgument ) );
    
    TMccRedPayloadReadPckg cPckg;
    cPckg.Copy( aConfigParams );
    iPLConfig = cPckg();

    __ASSERT_ALWAYS( iPLConfig.iRedBlockCount <= KMaxRedCount, 
        User::Leave( KErrArgument ) );
    
    if ( iSourceBuffer && iSourceBufOwnership )
        {
        delete iSourceBuffer;
        iSourceBuffer = NULL;
        }
    
    // Extra variables for clarity
    TInt redPayloadSize
        = iPLConfig.iMaxPayloadSize * ( 1 + iPLConfig.iRedBlockCount );
    TInt redHeadersSize 
        = iPLConfig.iRedBlockCount * KRedHeaderSize + KFinalHeaderSize;
    
    iSourceBuffer = CreateClipBufferL( redPayloadSize + redHeadersSize, 
        iSourceBufOwnership );
    iRedDecoder->InitializeL( iPLConfig.iRedBlockCount,
                              iPLConfig.iMaxPayloadSize, 
                              iPLConfig.iNumOfEncodings );
                              
    RArray<TUint> encPTs;
    CleanupClosePushL( encPTs );

    TInt maxNumOfEncodings = iPLConfig.iEncPayloadTypes.Count();
    for ( TInt i = 0; i < maxNumOfEncodings; i++ )
        {
        if ( KPayloadNotDefined != iPLConfig.iEncPayloadTypes[i] )
            {
            encPTs.AppendL( iPLConfig.iEncPayloadTypes[i] );
            }
        }

    User::LeaveIfError( iRedDecoder->SetPayloadTypes( encPTs ) );
    CleanupStack::PopAndDestroy( &encPTs );                              
    }
    
// -----------------------------------------------------------------------------
// CMccRedPayloadRead::BufferFilledL
// Redundancy format is decoded from parameter buffer and result is passed
// to the data sink of redundancy payload plugin.
// -----------------------------------------------------------------------------
//
void CMccRedPayloadRead::DataBufferFilledL( CMMFBuffer* aBuffer, 
                                        const TRtpRecvHeader& aRecvHeader )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::DataBufferFilledL" )
    
    __ASSERT_ALWAYS( aBuffer, User::Leave( KErrArgument ) );
    __ASSERT_ALWAYS( KUidMmfDataBuffer == aBuffer->Type(),
        User::Leave( KErrNotSupported ) );
    __ASSERT_ALWAYS( iDataSink, User::Leave( KErrNotReady ) );
    
    if ( aRecvHeader.iPayloadType == iPLConfig.iRedPayloadType )
        {
        iRedDecoder->SetEncodingBlockL( EMccRTPPayload, 
            static_cast<CMMFDataBuffer*>( aBuffer )->Data() );
        
        TInt numOfBlocks = User::LeaveIfError( 
            iRedDecoder->DecodePayload( aRecvHeader.iTimestamp ) );
        
        if ( numOfBlocks )
            {
            iRedDecoder->GetEncodingBlockL( 
                EMccPrimaryEncoding, iSinkBuffer->Data() );
            }
        }
    else
        {
        iSinkBuffer->Data().Copy( static_cast<CMMFDataBuffer*>( aBuffer )->Data() );
        }        
    
    DP_RED_DECODE( "CMccRedPayloadRead::DataBufferFilledL - Buffer decoded" )
        
    // Payload format read is data sink for redundancy plugin
    static_cast<CPayloadFormatRead*>( iDataSink )
        ->DataBufferFilledL( iSinkBuffer, aRecvHeader );
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::Streams
// NOT USED. Pure virtual method implementation from CMMFormatDecode needed.
// -----------------------------------------------------------------------------
//
TUint CMccRedPayloadRead::Streams( TUid aMediaType ) const
    {
    DP_RED_DECODE( "CMccRedPayloadRead::Streams" )
        
    if ( KUidMediaTypeAudio == aMediaType )
        {
        return 1;
        }
    else
        {
        return 0;
        }
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::FrameTimeInterval
// NOT USED. Pure virtual method implementation from CMMFormatDecode needed.
// -----------------------------------------------------------------------------
//
TTimeIntervalMicroSeconds CMccRedPayloadRead::FrameTimeInterval( 
        TMediaId /*aMediaType*/ ) const
    {
    DP_RED_DECODE( "CMccRedPayloadRead::FrameTimeInterval" )
        
    return TTimeIntervalMicroSeconds( TInt64( 0 ) );
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::Duration
// NOT USED. Pure virtual method implementation from CMMFormatDecode needed.
// -----------------------------------------------------------------------------
//
TTimeIntervalMicroSeconds   CMccRedPayloadRead::Duration( 
        TMediaId /*aMediaType*/ ) const
    {
    DP_RED_DECODE( "CMccRedPayloadRead::Duration" )

    return TTimeIntervalMicroSeconds( TInt64( 0 ) );
    }
        
// -----------------------------------------------------------------------------
// CMccRedPayloadRead::SourceDataTypeCode
// Returns the current datatype FourCC code.
// -----------------------------------------------------------------------------
//
TFourCC CMccRedPayloadRead::SourceDataTypeCode( TMediaId aMediaId )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::SourceDataTypeCode" )
        
    if ( KUidMediaTypeAudio == aMediaId.iMediaType )
        {
        return iFourCC;
        }
    else
        {
        return TFourCC(); //defaults to 'NULL' fourCC
        }
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::SetSourceDataTypeCode
// Sets source datatype fourCC code.
// -----------------------------------------------------------------------------
//
TInt CMccRedPayloadRead::SetSourceDataTypeCode( TFourCC aSourceFourCC,
                                                TMediaId aMediaId )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::SetSourceDataTypeCode" )
    
    if ( KUidMediaTypeAudio != aMediaId.iMediaType )
        {
        return KErrNotSupported;
        }
    
    iFourCC = aSourceFourCC;
    return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// CMccRedPayloadRead::CanCreateSourceBuffer
// 
// -----------------------------------------------------------------------------
//
TBool CMccRedPayloadRead::CanCreateSourceBuffer()
    {
    DP_RED_DECODE( "CMccRedPayloadRead::CanCreateSourceBuffer" )

    return ETrue;
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::CreateSourceBufferL
// 
// -----------------------------------------------------------------------------
//
CMMFBuffer* CMccRedPayloadRead::CreateSourceBufferL( TMediaId aMediaId, 
                                                     TBool& aReference )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::CreateSourceBufferL" )
    __ASSERT_ALWAYS( KUidMediaTypeAudio == aMediaId.iMediaType,
        User::Leave( KErrNotSupported ) );
    __ASSERT_ALWAYS( iSuggestedBufSize, User::Leave( KErrNotReady ) );
    
    aReference = EFalse;
    
    CMMFDataBuffer* buf = CMMFDataBuffer::NewL( iSuggestedBufSize );
    iSuggestedBufSize = 0;
    return buf;
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::FillBufferL
// 
// -----------------------------------------------------------------------------
//
void CMccRedPayloadRead::FillBufferL( CMMFBuffer* aBuffer, 
                                      MDataSink* aConsumer, 
                                      TMediaId aMediaId )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::FillBufferL" )

    __ASSERT_ALWAYS( NULL != aBuffer, User::Leave( KErrArgument ) );
    __ASSERT_ALWAYS( NULL != aConsumer, User::Leave( KErrArgument ) );
    __ASSERT_ALWAYS( KUidMediaTypeAudio == aMediaId.iMediaType,
        User::Leave( KErrNotSupported ) );
    __ASSERT_ALWAYS( KUidMmfDataBuffer == aBuffer->Type(),
        User::Leave( KErrNotSupported ) );
    
    iDataSink = aConsumer;
    iSinkBuffer = static_cast<CMMFDataBuffer*>( aBuffer );
    
    iClip->FillBufferL( iSourceBuffer, this, aMediaId );
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::SourceThreadLogon
// Passes state transition to the data source of redundancy payload plugin.
// -----------------------------------------------------------------------------
//
TInt CMccRedPayloadRead::SourceThreadLogon( MAsyncEventHandler& aEventHandler )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::SourceThreadLogon" )
        
    return iClip->SourceThreadLogon( aEventHandler );
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::SourceThreadLogoff
// Passes state transition to the data source of redundancy payload plugin.
// -----------------------------------------------------------------------------
//
void CMccRedPayloadRead::SourceThreadLogoff()
    {
    DP_RED_DECODE( "CMccRedPayloadRead::SourceThreadLogoff" )
        
    iClip->SourceThreadLogoff();
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::SourcePrimeL
// Passes state transition to the data source of redundancy payload plugin.
// -----------------------------------------------------------------------------
//
void CMccRedPayloadRead::SourcePrimeL()
    {
    DP_RED_DECODE( "CMccRedPayloadRead::SourcePrimeL" )
        
    iClip->SourcePrimeL();
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::SourcePlayL
// Passes state transition to the data source of redundancy payload plugin.
// -----------------------------------------------------------------------------
//
void CMccRedPayloadRead::SourcePlayL()
    {
    DP_RED_DECODE( "CMccRedPayloadRead::SourcePlayL" )
        
    iClip->SourcePlayL();
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::SourcePauseL
// Passes state transition to the data source of redundancy payload plugin.
// -----------------------------------------------------------------------------
//
void CMccRedPayloadRead::SourcePauseL()
    {
    DP_RED_DECODE( "CMccRedPayloadRead::SourcePauseL" )
        
    iClip->SourcePauseL();
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::SourceStopL
// Passes state transition to the data source of redundancy payload plugin.
// -----------------------------------------------------------------------------
//
void CMccRedPayloadRead::SourceStopL()
    {
    DP_RED_DECODE( "CMccRedPayloadRead::SourceStopL" )
        
    iClip->SourceStopL();
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::NegotiateSourceL
// Negotiate Source.
// -----------------------------------------------------------------------------
//
void CMccRedPayloadRead::NegotiateSourceL( MDataSink& aDataSink )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::NegotiateSourceL" )
        
    iDataSink = &aDataSink;
    iClip->NegotiateSourceL( *this );
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::SuggestSourceBufferSize
// 
// -----------------------------------------------------------------------------
//
void CMccRedPayloadRead::SuggestSourceBufferSize( TUint aSuggestedBufferSize )
    {
    iSuggestedBufSize = aSuggestedBufferSize;
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::SinkDataTypeCode
// Returns the current datatype FourCC code.
// -----------------------------------------------------------------------------
//
TFourCC CMccRedPayloadRead::SinkDataTypeCode( TMediaId aMediaId )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::SinkDataTypeCode" )
        
    if ( KUidMediaTypeAudio == aMediaId.iMediaType )
        {
        if ( iDataSink )
            {
            return iDataSink->SinkDataTypeCode( aMediaId );
            }
        else
            {
            return TFourCC();
            }
        }
    else
        {
        return TFourCC(); //defaults to 'NULL' fourCC
        }
    }

// -----------------------------------------------------------------------------
// CMccRedPayloadRead::SetPayloadTypes
// Set payload types to accept as encodings.
// -----------------------------------------------------------------------------
//
TInt CMccRedPayloadRead::SetPayloadTypes( RArray<TUint>& aPayloadTypes )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::SetPayloadTypes" )
    
    if ( aPayloadTypes.Count() )
        {
        iPLConfig.iRedPayloadType = static_cast<TUint8>( aPayloadTypes[0] );
        aPayloadTypes.Remove( 0 );
        
        return iRedDecoder->SetPayloadTypes( aPayloadTypes );
        }
    else
        {
        return KErrArgument;
        }
    }
    
// -----------------------------------------------------------------------------
// CMccRedPayloadRead::CreateClipBufferL
// Creates buffer needed in data transfer with format readers clip.
// -----------------------------------------------------------------------------
//
CMMFDataBuffer* CMccRedPayloadRead::CreateClipBufferL( 
        TUint aSize, TBool& aIsOwnBuffer )
    {
    DP_RED_DECODE( "CMccRedPayloadRead::CreateClipBufferL" )
    CMMFDataBuffer* buffer( NULL );
    
    if ( iClip->CanCreateSourceBuffer() )
        {
        static_cast<CMMFFormatDecode*>( iClip )->SuggestSourceBufferSize( aSize );
        
        TBool reference( EFalse );
        CMMFBuffer* sourceBuf 
            = iClip->CreateSourceBufferL( KUidMediaTypeAudio, reference );
        TBool isSupportedBuf 
            = CMMFBuffer::IsSupportedDataBuffer( sourceBuf->Type() );
        TBool isOwnBuffer = reference ? EFalse : ETrue;
        
        if ( !isSupportedBuf )
            {
            if ( isOwnBuffer )
                {
                delete sourceBuf;
                }
            
            User::Leave( KErrNotSupported );
            }
        
        aIsOwnBuffer = isOwnBuffer;
        buffer = static_cast<CMMFDataBuffer*>( sourceBuf );
        }
    else
        {
        aIsOwnBuffer = ETrue;
        buffer = CMMFDataBuffer::NewL( aSize );
        }
    
    return buffer;
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================


//  End of File