/*
* 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:
*
*/
#include "mcecomcodec.h"
#include "mceserial.h"
#include "mceevents.h"
#ifdef MCE_COMMON_SERVER_SIDE
#include <mmcccodecinformation.h>
#include "mcesrvstream.h"
#endif//MCE_COMMON_SERVER_SIDE
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CMceComCodec::CMceComCodec
// -----------------------------------------------------------------------------
//
CMceComCodec::CMceComCodec()
: iID( TMceMediaId( (TUint32)&iID ) ),
iPayloadType( 0 ),
iIsEnabled( ETrue ),
iBitrate( 0 ),
iAllowedBitrates( 0 ),
iCodecMode( 0 ),
iFourCC( 0 ),
iFrameSize( 0 ),
iState( CMceCodec::EEnabled ),
iPriority( 0 ),
iPriorityPreference( 0 ),
iKeepAliveTimer( 0 ),
iKeepAlivePayloadType( 0 ),
iIsNegotiated( ETrue ),
iCodecSdpIndex( 0 ),
iPreference( 0 )
{
}
// -----------------------------------------------------------------------------
// CMceComCodec::Id
// -----------------------------------------------------------------------------
//
TMceMediaId CMceComCodec::Id() const
{
return iID;
}
// -----------------------------------------------------------------------------
// CMceComCodec::Stream
// -----------------------------------------------------------------------------
//
CMceComMediaStream* CMceComCodec::Stream() const
{
return iStream;
}
// -----------------------------------------------------------------------------
// CMceComCodec::ConstructL
// -----------------------------------------------------------------------------
//
void CMceComCodec::ConstructL( CMceComCodec& aCodec )
{
iID = aCodec.iID;
iSdpName = aCodec.iSdpName;
iFmtpAttr = aCodec.iFmtpAttr ? aCodec.iFmtpAttr->AllocL() : NULL;
iPayloadType = aCodec.iPayloadType;
iFourCC = aCodec.iFourCC;
iBitrate = aCodec.iBitrate;
iAllowedBitrates = aCodec.iAllowedBitrates;
iCodecMode = aCodec.iCodecMode;
iFrameSize = aCodec.iFrameSize;
iState = aCodec.iState;
iPriority = aCodec.iPriority;
iPriorityPreference = aCodec.iPriorityPreference;
iKeepAliveTimer = aCodec.iKeepAliveTimer;
iKeepAlivePayloadType = aCodec.iKeepAlivePayloadType;
if ( aCodec.iKeepAliveData )
{
SetKeepAliveDataL( *aCodec.iKeepAliveData );
}
iIsNegotiated = aCodec.iIsNegotiated;
iCodecSdpIndex = aCodec.iCodecSdpIndex;
}
// -----------------------------------------------------------------------------
// CMceComCodec::SerializationId
// -----------------------------------------------------------------------------
//
TUint64 CMceComCodec::SerializationId() const
{
return iID.Uint64();
}
// -----------------------------------------------------------------------------
// CMceComCodec::InternalizeFlatL
// -----------------------------------------------------------------------------
//
void CMceComCodec::InternalizeFlatL( RReadStream& aReadStream )
{
MceSerial::DecodeL( iSdpName, aReadStream );
MceSerial::DecodeL( iID, aReadStream );
iPayloadType = aReadStream.ReadUint8L();
iFourCC = aReadStream.ReadUint32L();
iFrameSize = aReadStream.ReadUint32L();
iBitrate = aReadStream.ReadUint32L();
iAllowedBitrates = aReadStream.ReadUint32L();
iCodecMode = aReadStream.ReadUint32L();
iState = aReadStream.ReadInt32L();
iPriority = aReadStream.ReadInt32L();
iPriorityPreference = aReadStream.ReadInt32L();
iKeepAliveTimer = aReadStream.ReadUint32L();
iKeepAlivePayloadType = aReadStream.ReadUint32L();
MceSerial::DecodeL( iKeepAliveData, aReadStream );
}
// -----------------------------------------------------------------------------
// CMceComCodec::ExternalizeFlatL
// -----------------------------------------------------------------------------
//
void CMceComCodec::ExternalizeFlatL( RWriteStream& aWriteStream )
{
MceSerial::EncodeL( iSdpName, aWriteStream );
MceSerial::EncodeL( iID, aWriteStream );
aWriteStream.WriteUint8L( iPayloadType );
aWriteStream.WriteUint32L( iFourCC );
aWriteStream.WriteUint32L( iFrameSize );
aWriteStream.WriteUint32L( iBitrate );
aWriteStream.WriteUint32L( iAllowedBitrates );
aWriteStream.WriteUint32L( iCodecMode );
aWriteStream.WriteInt32L( iState );
aWriteStream.WriteInt32L( iPriority );
aWriteStream.WriteInt32L( iPriorityPreference );
aWriteStream.WriteInt32L( iKeepAliveTimer );
aWriteStream.WriteInt32L( iKeepAlivePayloadType );
MceSerial::EncodeL( iKeepAliveData, aWriteStream );
}
// -----------------------------------------------------------------------------
// CMceComCodec::InternalizeL
// -----------------------------------------------------------------------------
//
void CMceComCodec::InternalizeL( MMceComSerializationContext& aSerCtx )
{
InternalizeFlatL( aSerCtx.ReadStream() );
}
// -----------------------------------------------------------------------------
// CMceComCodec::ExternalizeL
// -----------------------------------------------------------------------------
//
void CMceComCodec::ExternalizeL( MMceComSerializationContext& aSerCtx )
{
ExternalizeFlatL( aSerCtx.WriteStream() );
}
// -----------------------------------------------------------------------------
// CMceComCodec::UpdateL
// -----------------------------------------------------------------------------
//
void CMceComCodec::UpdateL( CMceComCodec& aUpdate )
{
iSdpName = aUpdate.iSdpName;
iID = aUpdate.iID;
iPayloadType = aUpdate.iPayloadType;
iFourCC = aUpdate.iFourCC;
iBitrate = aUpdate.iBitrate;
iAllowedBitrates = aUpdate.iAllowedBitrates;
iCodecMode = aUpdate.iCodecMode;
iState = aUpdate.iState;
iPriority = aUpdate.iPriority;
iPriorityPreference = aUpdate.iPriorityPreference;
iKeepAliveTimer = aUpdate.iKeepAliveTimer;
iKeepAlivePayloadType = aUpdate.iKeepAlivePayloadType;
if ( aUpdate.iKeepAliveData )
{
delete iKeepAliveData;
iKeepAliveData = aUpdate.iKeepAliveData;
aUpdate.iKeepAliveData = NULL;
}
else
{
SetKeepAliveDataL( KNullDesC8 );
}
}
// -----------------------------------------------------------------------------
// CMceComCodec::ConstructL
// -----------------------------------------------------------------------------
//
void CMceComCodec::ConstructL( TMceComCodecName aSdpName )
{
iSdpName = aSdpName;
SetKeepAliveDataL( KNullDesC8 );
SetFmtpAttributeL( KNullDesC8 );
}
// -----------------------------------------------------------------------------
// CMceComCodec::Decodes
// -----------------------------------------------------------------------------
//
TBool CMceComCodec::Decodes(
const TDesC8& aRtpmapValue,
const TDesC8& /*aFmtpValue*/,
TBool /*aIsStrictMatch*/ )
{
// find MIME type
TInt slashPos = aRtpmapValue.Find( _L8( "/" ) );
if ( slashPos != KErrNotFound )
{
return aRtpmapValue.Left(slashPos).Compare( iSdpName ) == 0;
}
return aRtpmapValue.FindF(iSdpName) == 0;
}
// -----------------------------------------------------------------------------
// CMceComCodec::BaseFactory
// -----------------------------------------------------------------------------
//
TMceComFactory CMceComCodec::BaseFactory()
{
return TMceComFactory();
}
// -----------------------------------------------------------------------------
// CMceComCodec::FmtpAttr
// -----------------------------------------------------------------------------
//
TPtrC8 CMceComCodec::FmtpAttr() const
{
TPtrC8 existingFmtpVal( KNullDesC8() );
if ( iFmtpAttr && iFmtpAttr->Length() > 0 )
{
existingFmtpVal.Set( *iFmtpAttr );
}
else if ( iFmtpProposal )
{
existingFmtpVal.Set( *iFmtpProposal );
}
else
{
// NOP
}
return existingFmtpVal;
}
// -----------------------------------------------------------------------------
// CMceComCodec::SetFmtpAttributeL
// -----------------------------------------------------------------------------
//
void CMceComCodec::SetFmtpAttributeL( const TDesC8& aFmtpAttribute, TBool aReset )
{
if ( aReset || !iFmtpAttr )
{
HBufC8* fmtpAttr = aFmtpAttribute.AllocL();
delete iFmtpAttr;
iFmtpAttr = fmtpAttr;
}
else
{
iFmtpAttr = iFmtpAttr->ReAllocL( iFmtpAttr->Length() +
KMceFmtpSeparator().Length() +
aFmtpAttribute.Length() );
iFmtpAttr->Des().Append( KMceFmtpSeparator );
iFmtpAttr->Des().Append( aFmtpAttribute );
}
}
// -----------------------------------------------------------------------------
// CMceComCodec::~CMceComCodec
// -----------------------------------------------------------------------------
//
CMceComCodec::~CMceComCodec()
{
delete iFmtpAttr;
iFmtpAttr = NULL;
delete iKeepAliveData;
iKeepAliveData = NULL;
delete iFmtpProposal;
iFmtpProposal = NULL;
}
// -----------------------------------------------------------------------------
// CMceComCodec::EventReceivedL
// -----------------------------------------------------------------------------
//
TInt CMceComCodec::EventReceivedL( TMceEvent& aEvent )
{
TInt status = KMceEventNotOwner;
TBool idMatch = aEvent.Id().iCodecID == iID;
if ( !idMatch )
{
return KMceEventNotOwner;
}
if ( aEvent.Id().IsCodecId() )
{
status = KMceEventUpdate;
}
else
{
status = KMceEventNotConsumed;
}
return status;
}
// -----------------------------------------------------------------------------
// CMceComCodec::ResolveAllowedBitrates
// -----------------------------------------------------------------------------
//
TInt CMceComCodec::ResolveAllowedBitrates(
TUint /*aBitrate*/, TUint& /*aAllowedBitrates*/ )
{
return KErrNotSupported;
}
// -----------------------------------------------------------------------------
// CMceComCodec::SetEnabled
// -----------------------------------------------------------------------------
//
void CMceComCodec::SetEnabled( TBool aIsEnabled )
{
iIsEnabled = aIsEnabled;
}
// -----------------------------------------------------------------------------
// CMceComCodec::SendSupported
// -----------------------------------------------------------------------------
//
TBool CMceComCodec::SendSupported()
{
return ETrue;
}
// -----------------------------------------------------------------------------
// CMceComCodec::IsEnabled
// -----------------------------------------------------------------------------
//
TBool CMceComCodec::IsEnabled() const
{
return iIsEnabled;
}
// -----------------------------------------------------------------------------
// CMceComCodec::InitializeL
// -----------------------------------------------------------------------------
//
void CMceComCodec::InitializeL( CMceComMediaStream& aParent )
{
iStream = &aParent;
}
// -----------------------------------------------------------------------------
// CMceComCodec::SetKeepAliveDataL
// -----------------------------------------------------------------------------
//
void CMceComCodec::SetKeepAliveDataL( const TDesC8& aKeepAliveData )
{
HBufC8* keepaliveData = aKeepAliveData.AllocL();
delete iKeepAliveData;
iKeepAliveData = keepaliveData;
}
// -----------------------------------------------------------------------------
// CMceComCodec::SetBitrate
// -----------------------------------------------------------------------------
//
TInt CMceComCodec::SetBitrate( TUint aBitrate )
{
if ( aBitrate )
{
iBitrate = aBitrate;
return KErrNone;
}
else
{
return KErrArgument;
}
}
// -----------------------------------------------------------------------------
// CMceComCodec::SetAllowedBitrates
// -----------------------------------------------------------------------------
//
TInt CMceComCodec::SetAllowedBitrates( TUint aBitrates )
{
iAllowedBitrates = aBitrates;
return KErrNone;
}
// -----------------------------------------------------------------------------
// CMceComCodec::SetCodecMode
// -----------------------------------------------------------------------------
//
TInt CMceComCodec::SetCodecMode( TUint /*aCodecMode*/ )
{
return KErrNotSupported;
}
// -----------------------------------------------------------------------------
// CMceComCodec::SetPayloadType
// -----------------------------------------------------------------------------
//
TInt CMceComCodec::SetPayloadType( TUint8 aPayloadType )
{
if ( aPayloadType <= KMaxDynPayloadType )
{
iPayloadType = aPayloadType;
return KErrNone;
}
else
{
return KErrNotSupported;
}
}
// -----------------------------------------------------------------------------
// CMceComCodec::GetMaxBitRate
// -----------------------------------------------------------------------------
//
TUint CMceComCodec::GetMaxBitRate()
{
return iBitrate;
}
// -----------------------------------------------------------------------------
// CMceComCodec::TIterator::TIterator
// -----------------------------------------------------------------------------
//
CMceComCodec::TIterator::TIterator( const RPointerArray<CMceComCodec>& aCodecs,
CMceComCodec::TIterator::TFilter aFilter,
CMceComCodec* aCodec )
: iFilter( aFilter ),
iCodecs( aCodecs ),
iCurrentIndex( 0 ),
iCodec( aCodec )
{
}
// -----------------------------------------------------------------------------
// CMceComCodec::TIterator::IsEof
// -----------------------------------------------------------------------------
//
TBool CMceComCodec::TIterator::IsEof()
{
return iCodecs.Count() == 0 || iCurrentIndex >= iCodecs.Count();
}
// -----------------------------------------------------------------------------
// CMceComCodec::TIterator::Next
// -----------------------------------------------------------------------------
//
TBool CMceComCodec::TIterator::Next(
CMceComCodec*& aCandidate,
TIterator::TStreamStateMatchType aMatchType )
{
CMceComCodec* next = NULL;
while( !next && !IsEof() )
{
CMceComCodec* codec = iCodecs[ iCurrentIndex ];
TBool condition = EFalse;
switch( iFilter )
{
case EFilterIsNegotiated:
{
condition = codec->iIsNegotiated;
break;
}
case EFilterAssociatedLocal:
{
if ( iCodec &&
iCodec->Stream() &&
codec->Stream() &&
codec->Stream()->iStreamType == CMceComMediaStream::ELocalStream &&
( ( aMatchType == EOtherSdpName &&
!codec->Decodes( iCodec->iSdpName, iCodec->FmtpAttr() ) ) ||
( aMatchType == EExactMatch &&
codec->Decodes( iCodec->iSdpName, iCodec->FmtpAttr() ) ) ) )
{
CMceComMediaSource* source1 = iCodec->Stream()->Source();
CMceComMediaSource* source2 = codec->Stream()->Source();
condition = ( source1 != NULL && source1 == source2 );
}
break;
}
default:
{
condition = ETrue;
break;
}
}
next = condition ? codec : NULL;
iCurrentIndex++;
}
aCandidate = next;
return aCandidate ? ETrue : EFalse;
}
// -----------------------------------------------------------------------------
// CMceComCodec::TIterator::Reset
// -----------------------------------------------------------------------------
//
void CMceComCodec::TIterator::Reset()
{
iCurrentIndex = 0;
}
// -----------------------------------------------------------------------------
// CMceComCodec::TIterator::SetFilter
// -----------------------------------------------------------------------------
//
void CMceComCodec::TIterator::SetFilter(
CMceComCodec::TIterator::TFilter aFilter,
CMceComCodec* aCodec )
{
iFilter = aFilter;
iCodec = aCodec;
}
// -----------------------------------------------------------------------------
// CMceComCodec::TIterator::Count
// -----------------------------------------------------------------------------
//
TInt CMceComCodec::TIterator::Count()
{
TInt count = iCodecs.Count();
if ( iFilter )
{
TInt currentIndex = iCurrentIndex;
Reset();
CMceComCodec* codec = NULL;
count = 0;
while( Next( codec ) )
{
count++;
}
iCurrentIndex = currentIndex;
}
return count;
}
#ifdef MCE_COMMON_SERVER_SIDE
// -----------------------------------------------------------------------------
// CMceComCodec::SynchronizeL
// -----------------------------------------------------------------------------
//
void CMceComCodec::SynchronizeL( CMceComCodec& aCodec, TBool aRoleAnswerer )
{
if ( aRoleAnswerer )
{
SetFmtpFromIncomingSdpL( *aCodec.iFmtpAttr, aRoleAnswerer );
iPayloadType = aCodec.iPayloadType;
}
iCodecSdpIndex = aCodec.iCodecSdpIndex;
iIsNegotiated = aCodec.iIsNegotiated;
}
// -----------------------------------------------------------------------------
// CMceComCodec::MccPopulateL
// -----------------------------------------------------------------------------
//
void CMceComCodec::MccPopulateL( CMccCodecInformation& aMccCodec,
CMceSrvStream& aStream,
TMceNegotiationRole aRole )
{
MccEncodeL( aMccCodec, aStream );
if ( aRole == EMceRoleOfferer )
{
// Create fmtp
aMccCodec.CreateFmtpAttrListL();
}
UpdateL( aMccCodec );
}
// -----------------------------------------------------------------------------
// CMceComCodec::UpdateL
// -----------------------------------------------------------------------------
//
void CMceComCodec::UpdateL( CMccCodecInformation& aMccCodec )
{
SetFmtpAttributeL( aMccCodec.GetFmtpL() );
iSdpName = aMccCodec.SdpName();
}
// -----------------------------------------------------------------------------
// CMceComCodec::MccEncodeL
// -----------------------------------------------------------------------------
//
void CMceComCodec::MccEncodeL( CMccCodecInformation& aMccCodec,
CMceSrvStream& aStream )
{
// Encode common
EncodeCodecCommonL( aMccCodec );
// Encode codec specific stuff
DoMccEncodeL( aMccCodec, aStream );
}
// -----------------------------------------------------------------------------
// CMceComCodec::MccDecodeL
// -----------------------------------------------------------------------------
//
void CMceComCodec::MccDecodeL( CMccCodecInformation& aMccCodec )
{
TBool fmtpReady = iFmtpAttr && iFmtpAttr->Length();
if ( fmtpReady )
{
// Parse fmtp attribute
aMccCodec.SetFmtpAttrL( *iFmtpAttr );
}
// Copy common values from mcc codec
DecodeCodecCommonL( aMccCodec );
// Copy codec specific values from mcc codec
DoMccDecodeL( aMccCodec );
if ( !fmtpReady )
{
aMccCodec.CreateFmtpAttrListL();
}
SetFmtpAttributeL( aMccCodec.GetFmtpL() );
}
// -----------------------------------------------------------------------------
// CMceComCodec::MccValidateL
// -----------------------------------------------------------------------------
//
CMceComCodec* CMceComCodec::MccValidateL( CMccCodecInformation& aMccCodec,
CMceSrvStream& aStream,
TMceNegotiationRole aRole )
{
CMceComCodec* bidirectional = NULL;
aMccCodec.SetFmtpAttrL( *iFmtpAttr );
// Validation not needed for disabled streams
if ( aStream.Data().IsEnabled() )
{
// Do common validation
if( (TInt)aMccCodec.Bitrate() < 0 )
{
// Bitrate in the answer was out of range or
User::Leave( KErrNotSupported );
}
// Do codec specific validation
bidirectional = DoMccValidateL( aMccCodec, aStream, aRole );
}
//Validation ok => when answerer update mcc codec with codec values
// when offerer update codec with mcc codec values
if ( aRole == EMceRoleAnswerer )
{
// Encode
MccEncodeL( aMccCodec, aStream );
//update fmtp
UpdateL( aMccCodec );
}
else
{
// Copy common values from mcc codec
DecodeCodecCommonL( aMccCodec );
// Copy codec specific values from mcc codec
DoMccDecodeL( aMccCodec );
}
return bidirectional;
}
// -----------------------------------------------------------------------------
// CMceComCodec::MccAdjustL
// -----------------------------------------------------------------------------
//
void CMceComCodec::MccAdjustL( CMccCodecInformation& aMccCodec,
CMceSrvStream& aStream )
{
User::LeaveIfError( aMccCodec.SetPayloadType( iPayloadType ) );
DoMccAdjustL( aMccCodec, aStream );
}
// -----------------------------------------------------------------------------
// CMceComCodec::MccRequireSignalling
// -----------------------------------------------------------------------------
//
TInt CMceComCodec::MccRequireSignalling(
const CMceSrvStream& aStream,
const CMccCodecInformation& aMccCurentCodec,
const CMccCodecInformation& aMccUpdateCodec ) const
{
TInt action = KMceRequiresSignalling;
if ( !aMccCurentCodec.RequireSignalling( aMccUpdateCodec ) )
{
action = DoMccRequireSignalling( aStream, aMccCurentCodec, aMccUpdateCodec );
}
return action;
}
// -----------------------------------------------------------------------------
// CMceComCodec::SetState
// -----------------------------------------------------------------------------
//
void CMceComCodec::SetState( TMceMccComEvent& aEvent )
{
iIsEnabled = aEvent.iEvent == KMccStreamPrepared ?
ETrue :
aEvent.iEvent == KMccStreamStarted ?
ETrue :
aEvent.iEvent == KMccStreamStopped ?
EFalse :
aEvent.iEvent == KMccStreamPaused ?
EFalse :
aEvent.iEvent == KMccStreamResumed ?
ETrue : iIsEnabled;
}
// -----------------------------------------------------------------------------
// CMceComCodec::Merge
// -----------------------------------------------------------------------------
//
void CMceComCodec::Merge( CMceComCodec& aMergeWith )
{
CMceComMediaStream* stream = Stream();
if ( IS_RECEIVESTREAM( stream ) )
{
iIsEnabled = aMergeWith.iIsEnabled;
}
iIsNegotiated = aMergeWith.iIsNegotiated;
iCodecSdpIndex = aMergeWith.iCodecSdpIndex;
}
// -----------------------------------------------------------------------------
// CMceComCodec::SetFmtpProposalL
// -----------------------------------------------------------------------------
//
TBool CMceComCodec::SetFmtpProposalL( const TDesC8& aFmtpProposal )
{
HBufC8* proposal = aFmtpProposal.AllocL();
delete iFmtpProposal;
iFmtpProposal = proposal;
return ETrue;
}
// -----------------------------------------------------------------------------
// CMceComCodec::SetFmtpFromIncomingSdpL
// -----------------------------------------------------------------------------
//
void CMceComCodec::SetFmtpFromIncomingSdpL(
const TDesC8& aFmtpAttribute,
TBool /*aRoleAnswerer*/,
TBool aReset )
{
SetFmtpAttributeL( aFmtpAttribute, aReset );
}
// -----------------------------------------------------------------------------
// CMceComCodec::FtmpForOutgoingSdpLC
// -----------------------------------------------------------------------------
//
HBufC8* CMceComCodec::FtmpForOutgoingSdpLC()
{
HBufC8* fmtp = NULL;
if ( iFmtpAttr )
{
fmtp = iFmtpAttr->AllocLC();
}
else
{
fmtp = KNullDesC8().AllocLC();
}
return fmtp;
}
// -----------------------------------------------------------------------------
// CMceComCodec::EncodeCodecCommonL
// -----------------------------------------------------------------------------
//
void CMceComCodec::EncodeCodecCommonL( CMccCodecInformation& aMccCodec )
{
User::LeaveIfError( aMccCodec.SetPayloadType( iPayloadType ) );
User::LeaveIfError( aMccCodec.SetAllowedBitrates( iAllowedBitrates ) );
User::LeaveIfError( aMccCodec.SetCodecMode( (TCodecMode)iCodecMode ) );
User::LeaveIfError( aMccCodec.SetBitrate( iBitrate ) );
aMccCodec.SetPriority( iPriority );
aMccCodec.SetPriorityPreference( iPriorityPreference );
User::LeaveIfError( aMccCodec.SetKeepAliveTimer( iKeepAliveTimer ) );
User::LeaveIfError( aMccCodec.SetKeepAlivePT( iKeepAlivePayloadType ) );
if ( iKeepAliveData && iKeepAliveData->Length() > 0 )
{
User::LeaveIfError( aMccCodec.SetKeepAliveData( *iKeepAliveData ) );
}
}
// -----------------------------------------------------------------------------
// CMceComCodec::DecodeCodecCommonL
// -----------------------------------------------------------------------------
//
void CMceComCodec::DecodeCodecCommonL( CMccCodecInformation& aMccCodec )
{
iAllowedBitrates = aMccCodec.AllowedBitrates();
iCodecMode = (TUint32)aMccCodec.CodecMode();
iFourCC = aMccCodec.FourCC();
iFrameSize = aMccCodec.FrameSize();
iBitrate = aMccCodec.Bitrate();
iPriority = aMccCodec.Priority();
iPriorityPreference = aMccCodec.PriorityPreference();
iKeepAliveTimer = aMccCodec.KeepAliveTimer();
iKeepAlivePayloadType = aMccCodec.KeepAlivePT();
SetKeepAliveDataL( aMccCodec.KeepAliveData() );
}
// -----------------------------------------------------------------------------
// CMceComCodec::SetDefaultFmtpAttributeL
// -----------------------------------------------------------------------------
//
void CMceComCodec::SetDefaultFmtpAttributeL()
{
DoSetDefaultFmtpAttributeL();
}
// -----------------------------------------------------------------------------
// CMceComCodec::DoMccValidateL
// -----------------------------------------------------------------------------
CMceComCodec* CMceComCodec::DoMccValidateL( CMccCodecInformation& aMccCodec,
CMceSrvStream& /*aStream*/,
TMceNegotiationRole /*aRole*/ )
{
if ( aMccCodec.CodecMode() != (TCodecMode)iCodecMode )
{
// codec-mode was different, fail.
User::Leave(KErrNotSupported);
}
return NULL;
}
#endif//MCE_COMMON_SERVER_SIDE