/*

* Copyright (c) 2005 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:    MCC Redundancy CodecInformation

*

*/

// INCLUDE FILES

#include "mmcccodecred.h"

#include "mccuids.hrh"

#include "mmccinterfacelogs.h"

#include "mccinternalcodecs.h"

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

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

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

// CMccCodecRed::CMccCodecRed

// default constructor

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

//

CMccCodecRed::CMccCodecRed() : CMccCodecInformation()

    {

    }

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

// CMccCodecRed::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMccCodecRed::ConstructL()

    {

    iSdpName.Copy( KRedSdpName );

    iFmtpAttr = HBufC8::NewL( 1 );

    TPtr8 ptr = iFmtpAttr->Des();

    ptr.Append( KNullDesC );

    SetSamplingFreq( KRedSamplingFreq );

    EnableVAD( EFalse );

    SetMaxPTime( KRedMaxPTime ); // recommended "limit" 200ms

    SetPTime( KRedPTime ); // default 20ms 

    SetPayloadType( KDefaultRedPT );  

    iFourCC = KMccFourCCIdRed;

    iCodecMode = ENothing;

    iPayloadFormatEncoder = KImplUidRedPayloadFormatEncode;

    iPayloadFormatDecoder = KImplUidRedPayloadFormatDecode;

    }

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

// CMccCodecRed::NewLC

// Static constructor.

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

//

CMccCodecRed* CMccCodecRed::NewL()

    {

    CMccCodecRed* self = new (ELeave) CMccCodecRed;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); 

    return self;

    }

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

// CMccCodecRed::~CMccCodecRed

// Destructor

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

//

CMccCodecRed::~CMccCodecRed()

    {

    iRedPayloads.Reset();

    iRedPayloads.Close();

    }

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

// CMccCodecRed::RequireSignalling

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

//

TBool CMccCodecRed::RequireSignalling(

    const CMccCodecInformation& aCandidate ) const      

    {

    __INTERFACE( "CMccCodecRed::RequireSignalling" )

    const CMccCodecRed& candidate = static_cast<const CMccCodecRed&>( aCandidate );

    TBool ret = EFalse;

    if ( iPTime != candidate.PTime() )

        {

        __INTERFACE( "CMccCodecRed::RequireSignalling, PTime changed" )

        ret = ETrue;

        }

    if ( iMaxPTime != candidate.MaxPTime() )

        {

        __INTERFACE( "CMccCodecRed::RequireSignalling, MaxPTime changed" )

        ret = ETrue;

        }

    if ( iPayloadType != candidate.PayloadType() )

        {

        __INTERFACE( "CMccCodecRed::RequireSignalling, PayloadType changed" )

        ret = ETrue;

        }

    if ( iCodecMode != candidate.CodecMode() )

        {

        __INTERFACE( "CMccCodecRed::RequireSignalling, CodecMode changed" )

        ret = ETrue;

        }     

    const RArray<TUint>& candidatePayloads = candidate.RedPayloads();    

    if ( candidatePayloads.Count() != iRedPayloads.Count() )

        {

        __INTERFACE( "CMccCodecRed::RequireSignalling, RedPayloads changed" )

        ret = ETrue;

        }

    else

        {

        for ( TInt i = 0; i < candidatePayloads.Count(); i++ )

            {

            if ( candidatePayloads[ i ] != iRedPayloads[ i ] )

                {

                __INTERFACE( "CMccCodecRed::RequireSignalling, RedPayload changed" )

                ret = ETrue;

                }

            }

        }

    __INTERFACE_INT1( "CMccCodecRed::RequireSignalling, exit with", ret )

    return ret;          

    }

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

// CMccCodecRed::SetBitrate

// Sets the bitrate used with Redundacy codec.

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

//

TInt CMccCodecRed::SetBitrate( TUint aBitrate )

    {

    iBitrate = aBitrate;

    return KErrNone;

    }

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

// CMccCodecRed::SetSamplingFreq

// Sets the sampling frequency. 

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

//

TInt CMccCodecRed::SetSamplingFreq( TUint32 aSamplingFreq )

    {

    iSamplingFreq = aSamplingFreq;

    return KErrNone;

    }

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

// CMccCodecRed::SetSdpName

// Sets the SDP name

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

TInt CMccCodecRed::SetSdpName( const TDesC8& aSdpName )

    {

    if ( !aSdpName.CompareF( KRedSdpName ) )

        {

        iSdpName.Copy( aSdpName );

        }

    else 

        {

        return KErrNotSupported;

        }

    return KErrNone;

    }

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

// CMccCodecRed::PayloadType

// Sets the payload type

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

TInt CMccCodecRed::SetPayloadType( TUint8 aPayloadType )

    {

    if ( aPayloadType < KMinDynamicPT ||

         aPayloadType > KMaxPayloadType ) 

        {

        return KErrNotSupported;

        }

    else 

        {

        iPayloadType = aPayloadType;

        return KErrNone;

        }

    }

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

// CMccCodecRed::SetCodecMode

// Sets the codec mode

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

TInt CMccCodecRed::SetCodecMode( TCodecMode aCodecMode )

    {

    if ( ENothing == aCodecMode )

        {

        iCodecMode = aCodecMode;

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecRed::EnableVAD

// 

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

TInt CMccCodecRed::EnableVAD( TBool aEnableVAD ) 

    {

    iEnableVAD = aEnableVAD;        

    return KErrNone;

    }

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

// CMccCodecRed::SetPTime

//

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

//

TInt CMccCodecRed::SetPTime( TUint aPTime )

    {

    if ( aPTime && ( KMinPtime <= aPTime ) &&  ( aPTime <= KMaxPtime ) && 

        (( aPTime % KMinPtime )  == 0 ))

        {

        iPTime = aPTime;

        return KErrNone;    

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecRed::SetMaxPTime

//

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

//

TInt CMccCodecRed::SetMaxPTime( TUint aMaxPTime )

    {

    if ( aMaxPTime && ( iPTime <= aMaxPTime )&& ( KMinPtime <= aMaxPTime ) && 

        ( aMaxPTime <= KMaxPtime ) && (( aMaxPTime % KMinPtime )  == 0 ) )

        {

        iMaxPTime = aMaxPTime;

        return KErrNone;    

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecInformation::ParseFmtpAttr

// Parses the fmtp attribute

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

//

TBool CMccCodecRed::ParseFmtpAttrL( const TDesC8& aFmtp )

    {

    // Parse codecs used for primary and secondary etc. codecs from the 

    // fmtp attribute

    // example fmtp attribute:

    // a=fmtp:99 0/103 

    // 99 is the redundancy format payload type

    // 0 is the primary codecs payload type

    // 103 is the secondary codecs payload type

    // NOTE: currently redundancy is allowed only for single payload type

    TBool updated( EFalse );

    TInt nextIndex = 0;

    TInt prevIndex = 0;

    TUint8 prevPayloadFormat = KMccPayloadTypeMax;

    HBufC8* modifyBuf = HBufC8::NewLC( aFmtp.Length() );

    TPtr8 pFmtpValue( modifyBuf->Des() );

    pFmtpValue = aFmtp;

    if( aFmtp.Length() > 0 )

        {   

        // Search for all the slashes and convert number strings between them

        // to integers    

        TBool found = ETrue;

        while( EFalse != found )

            {     

            pFmtpValue = modifyBuf->Mid( nextIndex );

            nextIndex = pFmtpValue.Locate( KCharSlash );          

            if( ( KErrNotFound == nextIndex ) ) 

                {

                found = EFalse;

                if( 0 != pFmtpValue.Length() )

                    {

                    nextIndex = pFmtpValue.Length(); // Handle last payload value      

                    }

                }

            if( 0 != pFmtpValue.Length() )

                {

                TLex8 lex = pFmtpValue.Mid( prevIndex, (nextIndex - prevIndex) );

                TUint8 payloadFormat;

                TInt err = lex.Val( payloadFormat, EDecimal );

                if( KErrNone == err )

                    {

                    if ( prevPayloadFormat != KMccPayloadTypeMax &&

                         prevPayloadFormat != payloadFormat )

                         {

                         iRedPayloads.Reset();

                         User::Leave( KErrNotSupported );

                         }

                    iRedPayloads.AppendL( static_cast<TUint>( payloadFormat ) );  

                    updated = ETrue;  

                    prevPayloadFormat = payloadFormat;  

                    }

                nextIndex++;         

                prevIndex = 0;

                }

            }

        }

    CleanupStack::PopAndDestroy( modifyBuf );

    return updated;

    }

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

// CMccCodecRed::SetAllowedBitrates

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

// 

TInt CMccCodecRed::SetAllowedBitrates( TUint /*aBitrateMask*/ )

    {

    return KErrNone;           

    }

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

// CMccCodecRed::SetRedCodecs

// Set the payload types used in redundancy

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

//

void CMccCodecRed::SetRedPayloadsL( RArray<TUint>& aRedPayloads )

    {

    iRedPayloads.Reset();

    TInt i;

    for( i = 0; i < aRedPayloads.Count(); i++ )

        {

        iRedPayloads.AppendL( aRedPayloads[ i ] );  

        }

    // Convert parsed payload formats back to string and set

    // the iFmtpAttr variable

    const TInt KCharsPerPayload( 4 );

    delete iFmtpAttr;

    iFmtpAttr = NULL;

    iFmtpAttr = HBufC8::NewL( iRedPayloads.Count() * KCharsPerPayload );

    TPtr8 descPtr = iFmtpAttr->Des();

    for( i = 0; i < iRedPayloads.Count(); i++ )

        {

        descPtr.AppendNum( static_cast<TUint64>( iRedPayloads[i] ), EDecimal );

        descPtr.Append( KCharSlash );       

        }   

    // Remove the last slash character

    descPtr.SetLength( descPtr.Length() - 1 );  

    }

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

// CMccCodecRed::RedPayloadsL

// Fills array with red payload type values

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

//

void CMccCodecRed::RedPayloadsL( RArray<TUint>& aRedPayloads ) const

    {

    for ( TInt i = 0; i < iRedPayloads.Count(); i++ )

        {

        aRedPayloads.AppendL( iRedPayloads[ i ] );

        }

    }

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

// CMccCodecInformation::RedPayloads

// Return the reference to the redundancy codecs array

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

//

const RArray<TUint>& CMccCodecRed::RedPayloads() const

    {

    return iRedPayloads;

    }

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

// CMccCodecRed::CloneDefaultsL

// Make a default setting clone from this Redundancy codec

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

//

CMccCodecInformation* CMccCodecRed::CloneDefaultsL()

    {

    return CMccCodecRed::NewL();

    }

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

// CMCCAMRCodec::CloneDetailedL

// Make a detailed clone from this Redundancy codec

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

//

CMccCodecInformation* CMccCodecRed::CloneDetailedL()

    {

    CMccCodecRed* newCodec = CMccCodecRed::NewL();

    CleanupStack::PushL( newCodec );   

    newCodec->SetBitrate( this->Bitrate() );

    newCodec->SetCodecMode( this->CodecMode() );

    newCodec->SetMaxPTime( this->MaxPTime() );

    newCodec->SetPayloadType( this->PayloadType() );

    newCodec->SetPTime( this->PTime() );

    newCodec->SetSamplingFreq( this->SamplingFreq() );

    newCodec->SetSdpName( this->SdpName() );

    newCodec->ParseFmtpAttrL( this->GetFmtpL() );

    CleanupStack::Pop( newCodec );       

    return newCodec;

    }

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

//  End of File