/*

* Copyright (c) 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:    

*

*/

// INCLUDE FILES

#include "mmcccodecavc.h"

#include "mccuids.hrh"

#include "mmccinterfacelogs.h"

#include "CMccController_stub.h"

#include <delimitedpathsegment8.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

const TInt KMaxFmtpAttrLength( 200 );

const TInt KAvcDefaultFrameSize( 10000 );

const TInt KAvcLevel1Bitrate( 64000 );

const TInt KAvcLevel1bBitrate( 128000 );

const TInt KAvcLevel11Bitrate( 192000 );

const TInt KAvcLevel12Bitrate( 384000 );

const TInt KAvcLevel13Bitrate( 768000 );

const TInt KAvcLevel2Bitrate( 2000000 );

const TInt KAvcDefaultFreq( 90000 );

const TInt KAvcProfileLevelIdStrLen = 6;

const TInt KAvcProfileLevelIdValLen = 2;

const TUint KAvcProfileIopValueShift = 5;

const TUint KAvcProfileIopFlagForLevel1b = 0x10;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CMccCodecAVC::CMccCodecAVC

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

// might leave.

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

//

CMccCodecAVC::CMccCodecAVC() : CMccCodecInformation()

    {

    }

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

// CMccCodecAVC::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMccCodecAVC::ConstructL()

    {

    iSdpName.Copy( KAVCSdpName );

    iBitrateMask = KMccAvcCodecProfileIdBaseline | 

                   KMccAvcCodecProfileIopConstraintSet | 

                   KMccAvcBitrateLevel1;

    iType = KUidMediaTypeVideo; 

    iFmtpAttr = HBufC8::NewL( KMaxFmtpAttrLength );

    iFourCC = KMccFourCCIdAVC;

    iSamplingFreq = KAvcDefaultFreq;

    iPayloadFormatEncoder = KImplUidAvcPayloadFormatEncode;

    iPayloadFormatDecoder = 0;

    SetCodecMode( KAvcFormatModeSingleNal );

    SetPTime( KAvcPTime );

    SetPayloadType( KAvcPayloadType );

    SetFramerate( KAvcFramerate );

    SetLevelBasedBitrate( KAvcLevel1Bitrate );

    SetMaxBitrate( KAvcLevel1Bitrate );

    SetFrameHeight( KAvcFrameHeight );

    SetFrameWidth( KAvcFrameWidth );

    iFrameSize = KAvcDefaultFrameSize;

    }

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

// CMccCodecAVC::NewL

// Two-phased constructor.

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

//

CMccCodecAVC* CMccCodecAVC::NewL()

    {

    CMccCodecAVC* self = new( ELeave ) CMccCodecAVC;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMccCodecAVC::~CMccCodecAVC

// 

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

//

CMccCodecAVC::~CMccCodecAVC()

    {

    }

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

// CMccCodecAVC::RequireSignalling

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

//

TBool CMccCodecAVC::RequireSignalling(

    const CMccCodecInformation& aCandidate ) const      

    {

    return CMccCodecInformation::RequireSignalling( aCandidate );

    }

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

// CMccCodecAVC::GetFmtpL

// Gets the fmtp attribute

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

//

TDesC8& CMccCodecAVC::GetFmtpL()

    {

    return CMccCodecInformation::GetFmtpL();

    }    

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

// CMccCodecAVC::CreateFmtpAttrListL

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

//

void CMccCodecAVC::CreateFmtpAttrListL()

    {

    HBufC8* buf = HBufC8::NewLC( KMaxFmtpAttrLength ); 

    TPtr8 bufPtr = buf->Des();

    TBool previousParamAdded( EFalse );

    if ( CreateFmtpProfileLevelId( bufPtr ) )

        {

        previousParamAdded = ETrue;

        }

    TInt semicolonPos( bufPtr.Length() );

    if ( CreateFmtpPacketizationMode( bufPtr ) )

        {

        // Previous param was added, so we need a semi-colon and a space

        if ( previousParamAdded )

            {

            bufPtr.Insert( semicolonPos, KSemicolonSpace );

            }

        previousParamAdded = ETrue;

        }

    semicolonPos = bufPtr.Length();

    if ( CreateFmtpSpropParameterSets( bufPtr ) )

        {

        // Previous param was added, so we need a semi-colon and a space

        if ( previousParamAdded )

            {

            bufPtr.Insert( semicolonPos, KSemicolonSpace );

            }

        previousParamAdded = ETrue;

        }

    // Update iFmtpAttr

    SetFmtpAttrL( bufPtr, EFalse );

    CleanupStack::PopAndDestroy( buf );

    }

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

// CMccCodecAVC::ParseFmtpAttrL

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

//

TBool CMccCodecAVC::ParseFmtpAttrL( const TDesC8& aFmtp )

    {

    // These booleans needed in FMTP parsing to handle where parameters

    // not present in FMTP

    iProfileLevelIdParamExists = EFalse;

    iPacketizationModeParamExists = EFalse;

    //Remove all white space from begining and end,

    //Convert the content of the descriptor to lower case

    const TUint8* pointerC = aFmtp.Ptr();

    TUint8* pointer        = const_cast<TUint8*>( pointerC );

    TPtr8 descriptor( pointer, aFmtp.Length(), aFmtp.Length() );

    descriptor.Trim();

    /*

    TDelimitedPathSegmentParser8 Parses path segments whose 

    components are delimited by the ';' character, 

    as defined in RFC2396.

    */

    TDelimitedPathSegmentParser8 parser;

    parser.Parse( aFmtp );

    TPtrC8 segment;

    TBool updated( EFalse );

    while ( parser.GetNext( segment ) != KErrNotFound )

        {

        if ( ParseFmtpSegmentL( segment ) )

            {

            updated = ETrue;

            }

        }

    if ( !iProfileLevelIdParamExists )

        {

        SetProfileLevelIdL( KMccAvcCodecProfileIdBaselineVal, 

                            DefaultProfileIopVal(),

                            KMccAvcCodecProfileLevel1Val );

        }

    if ( !iPacketizationModeParamExists )

        {

        User::LeaveIfError( SetCodecMode( KAvcFormatModeSingleNal ) );

        }

    return updated;

    }    

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

// CMccCodecAVC::ParseFmtpSegmentL

// Parse and updates the matched param

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

//    

TBool CMccCodecAVC::ParseFmtpSegmentL( const TDesC8& aSeg )

    {

    TBool update( EFalse );

    _LIT8( KEqualSign, "=" );

    // Check for first '=' sign 

    TInt index = aSeg.Find( KEqualSign );

    if ( index > 0 )

        {

        // Check if match mode-set 

        if ( aSeg.Left( index ).Match( KMatchProfileLevelId ) != KErrNotFound )

            {

            update = ParseFmtpProfileLevelIdL( 

                            aSeg.Right( aSeg.Length() - ( index + 1 ) ) );

            iProfileLevelIdParamExists = ETrue;

            } 

        else if ( aSeg.Left( index ).Match( KMatchSpropParameterSets ) != KErrNotFound )

            {

            update = ParseFmtpSpropParameterSetsL( 

                            aSeg.Right( aSeg.Length() - ( index + 1 ) ) );

            }   

        else if ( aSeg.Left( index ).Match( KMatchPacketizationMode ) != KErrNotFound )

            {

            update = ParseFmtpPacketizationModeL( 

                            aSeg.Right( aSeg.Length() - ( index + 1 ) ) );

            iPacketizationModeParamExists = ETrue;

            }

        else

            {

            }

        }

    return update;

    }

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

// CMccCodecAVC::ParseFmtpProfileLevelIdL

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

//    

TBool CMccCodecAVC::ParseFmtpProfileLevelIdL( const TDesC8& aProfileLevelId )

    {

    // A base16 [6] (hexadecimal) representation of

    // the following three bytes in the sequence

    // parameter set NAL unit specified in [1]: 1)

    // profile_idc, 2) a byte herein referred to as

    // profile-iop, composed of the values of

    // constraint_set0_flag, constraint_set1_flag,

    // constraint_set2_flag, and reserved_zero_5bits

    // in bit-significance order, starting from the

    // most significant bit, and 3) level_idc.  Note

    // that reserved_zero_5bits is required to be

    // equal to 0 in [1], but other values for it may

    // be specified in the future by ITU-T or ISO/IEC.

    __ASSERT_ALWAYS( aProfileLevelId.Length() == KAvcProfileLevelIdStrLen, 

                     User::Leave( KErrArgument ) );

    TInt startPos( 0 );

    TLex8 profileIdLex( aProfileLevelId.Mid( startPos, KAvcProfileLevelIdValLen ) );

    startPos += KAvcProfileLevelIdValLen;

    TUint profileId( 0 );

    User::LeaveIfError( profileIdLex.Val( profileId, EHex ) );

    TLex8 profileIopLex( aProfileLevelId.Mid( startPos, KAvcProfileLevelIdValLen ) );

    startPos += KAvcProfileLevelIdValLen;

    TUint profileIop( 0 );

    User::LeaveIfError( profileIopLex.Val( profileIop, EHex ) );

    TLex8 profileLevelLex( aProfileLevelId.Mid( startPos, KAvcProfileLevelIdValLen ) );

    TUint profileLevel( 0 );

    User::LeaveIfError( profileLevelLex.Val( profileLevel, EHex ) );

    SetProfileLevelIdL( profileId, profileIop, profileLevel );

    return ETrue;

    }

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

// CMccCodecAVC::ParseFmtpSpropParameterSetsL

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

//    

TBool CMccCodecAVC::ParseFmtpSpropParameterSetsL( const TDesC8& aSpropParameterSets )

    {

    const TInt KMccMaxSpropParameterSetLen = 100;

    __ASSERT_ALWAYS( aSpropParameterSets.Length() > 0 &&

                     aSpropParameterSets.Length() <= KMccMaxSpropParameterSetLen, 

                     User::Leave( KErrArgument ) );

    HBufC8* sprop = aSpropParameterSets.AllocL();

    delete iConfigKey;

    iConfigKey = sprop;

    return ETrue;

    }

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

// CMccCodecAVC::ParseFmtpPacketizationModeL

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

//    

TBool CMccCodecAVC::ParseFmtpPacketizationModeL( const TDesC8& aPacketizationMode )

    {

    // Convert descriptor to integer

    TLex8 myLex( aPacketizationMode );

    TInt packetizationMode;

    User::LeaveIfError( myLex.Val( packetizationMode ) );

    User::LeaveIfError( SetCodecMode( packetizationMode ) );

    return ETrue;

    }            

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

// CMccCodecAVC::SetBitrate

// Sets the bitrate used with AMR codec.

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

//

TInt CMccCodecAVC::SetBitrate( TUint aBitrate )

    {

    if ( aBitrate > 0 && aBitrate <= KAvcLevel2Bitrate )

        {            

        iBitrate = aBitrate;

        iBitrateSet = ETrue;

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecAVC::SetSamplingFreq

// Sets the sampling frequency. 

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

//

TInt CMccCodecAVC::SetSamplingFreq( TUint32 /*aSamplingFreq*/ )

    {

    return KErrNone;

    }

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

// CMccCodecAVC::SetSdpName

// Sets the SDP name

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

//

TInt CMccCodecAVC::SetSdpName( const TDesC8& aSdpName )

    {

    if ( 0 == aSdpName.CompareF( KAVCSdpName ) )

        {

        iSdpName.Copy( aSdpName );

        }

    else 

        {

        return KErrNotSupported;

        }

    return KErrNone;

    }

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

// CMccCodecAVC::PayloadType

// Sets the payload type

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

//

TInt CMccCodecAVC::SetPayloadType( TUint8 aPayloadType )

    {

    if ( aPayloadType < KMinDynamicPT ||

         aPayloadType > KMaxPayloadType ) 

        {

        return KErrNotSupported;

        }

    else 

        {

        iPayloadType = aPayloadType;

        }

    return KErrNone;

    }

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

// CMccCodecAVC::SetCodecMode

// Sets the codec mode

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

//

TInt CMccCodecAVC::SetCodecMode( TCodecMode aCodecMode )

    {

    if ( KAvcFormatModeSingleNal == aCodecMode || 

         KAvcFormatModeNonInterleaved == aCodecMode )

        {

        iCodecMode = aCodecMode;

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecAVC::SetFmtpAttrL

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

//

void CMccCodecAVC::SetFmtpAttrL( const TDesC8& /*aFmtp*/, TBool /*parseFmtp*/ )

    {

    if ( CMccControllerStub::Stub() && CMccControllerStub::Stub()->iSetFmtpFailure )

        {

        User::Leave( KErrNotSupported );

        }

    }

TInt CMccCodecAVC::SetAllowedBitrates( TUint aBitrateMask )

    {

    //Confirm that the bitrate mask is valid

    //I.e. after all the valid bitrates are set to zero the value should be zero

    if ( (aBitrateMask >> 16 ) > 0 )

        {

        return KErrArgument;

        }

    else

        {

        SetBitrateMask( KMccAllowedAvcBitrateAll & aBitrateMask );

        SetBitrateMaskAdditionalInfo( aBitrateMask );

        SetBitrateFromBitrateMask( iBitrateMask );

        }

    return KErrNone;

    }

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

// CMccCodecAVC::EnableVAD

// Enable / Disable VAD

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

//

TInt CMccCodecAVC::EnableVAD( TBool /*aEnableVAD*/ ) 

    {

    return KErrNotSupported;

    }

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

// CMccCodecAVC::SetPTime

// Set PTime

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

//

TInt CMccCodecAVC::SetPTime( TUint aPTime )

    {

    if ( ( aPTime <= 200 ) && (( aPTime % 10 )  == 0 ))

        {

        iPTime = aPTime;

        return KErrNone;    

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecAVC::SetMaxPTime

// Set Max PTime

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

//

TInt CMccCodecAVC::SetMaxPTime( TUint aMaxPTime )

    {

    if ( ( aMaxPTime <= 200 ) && (( aMaxPTime % 10 )  == 0 ))

        {

        iMaxPTime = aMaxPTime;

        return KErrNone;    

        }

    else

        {

        return KErrNotSupported;

        }