/*
* 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 "mcecomvideocodec.h"
#include "mceserial.h"
#include "mceevents.h"
#include "mcecomrtpsource.h"
#include "mcertpsource.h"
#ifdef MCE_COMMON_SERVER_SIDE
#include <mmcccodecinformation.h>
#include "mcesrvstream.h"
#include "mcesrvsource.h"
#endif//MCE_COMMON_SERVER_SIDE
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CMceComVideoCodec::NewL
// -----------------------------------------------------------------------------
//
CMceComVideoCodec* CMceComVideoCodec::NewL( TBuf8<KMceMaxSdpNameLength> aSdpName )
{
CMceComVideoCodec* self = NewLC( aSdpName );
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::NewLC
// -----------------------------------------------------------------------------
//
CMceComVideoCodec* CMceComVideoCodec::NewLC( TBuf8<KMceMaxSdpNameLength> aSdpName )
{
CMceComVideoCodec* self = new (ELeave) CMceComVideoCodec();
CleanupStack::PushL( self );
self->ConstructL( aSdpName );
return self;
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::~CMceComAMRCodec
// -----------------------------------------------------------------------------
//
CMceComVideoCodec::~CMceComVideoCodec()
{
delete iConfigKey;
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::CMceComVideoCodec
// -----------------------------------------------------------------------------
//
CMceComVideoCodec::CMceComVideoCodec()
:CMceComCodec(),
iFrameRate( 0 ),
iMaxBitRate( 0 ),
iAllowedResolutions( 0 ),
iResolutionWidth( 0 ),
iResolutionHeight( 0 ),
iAllowedFrameRates( 0 ),
iClockRate( 0 ),
iReceiveFrameRate( 0 ),
iEncodingDecodingDevice( KNullUid )
{
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::ConstructL
// -----------------------------------------------------------------------------
//
CMceComVideoCodec* CMceComVideoCodec::CloneL()
{
CMceComVideoCodec* copy = new (ELeave) CMceComVideoCodec();
CleanupStack::PushL( copy );
copy->ConstructL( *this );
CleanupStack::Pop( copy );
return copy;
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::ConstructL
// -----------------------------------------------------------------------------
//
void CMceComVideoCodec::ConstructL( TBuf8<KMceMaxSdpNameLength> aSdpName )
{
CMceComCodec::ConstructL( aSdpName );
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::ConstructL
// -----------------------------------------------------------------------------
//
void CMceComVideoCodec::ConstructL( CMceComVideoCodec& aCodec )
{
CMceComCodec::ConstructL( aCodec );
iFrameRate = aCodec.iFrameRate;
iMaxBitRate = aCodec.iMaxBitRate;
iAllowedResolutions = aCodec.iAllowedResolutions;
iResolutionWidth = aCodec.iResolutionWidth;
iResolutionHeight = aCodec.iResolutionHeight;
iAllowedFrameRates = aCodec.iAllowedFrameRates;
iClockRate = aCodec.iClockRate;
iReceiveFrameRate = aCodec.iReceiveFrameRate;
SetConfigKeyL( aCodec.iConfigKey );
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::InternalizeFlatL
// -----------------------------------------------------------------------------
//
void CMceComVideoCodec::InternalizeFlatL( RReadStream& aReadStream )
{
CMceComCodec::InternalizeFlatL( aReadStream );
iFrameRate = aReadStream.ReadReal64L();
iMaxBitRate = aReadStream.ReadUint32L();
iAllowedResolutions = aReadStream.ReadUint32L();
iResolutionWidth = aReadStream.ReadInt32L();
iResolutionHeight = aReadStream.ReadInt32L();
iAllowedFrameRates = aReadStream.ReadUint32L();
iClockRate = aReadStream.ReadUint32L();
iReceiveFrameRate = aReadStream.ReadReal64L();
MceSerial::DecodeL( iConfigKey, aReadStream );
iEncodingDecodingDevice.iUid = aReadStream.ReadUint32L();
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::ExternalizeFlatL
// -----------------------------------------------------------------------------
//
void CMceComVideoCodec::ExternalizeFlatL( RWriteStream& aWriteStream )
{
CMceComCodec::ExternalizeFlatL( aWriteStream );
aWriteStream.WriteReal64L( iFrameRate );
aWriteStream.WriteUint32L( iMaxBitRate );
aWriteStream.WriteUint32L( iAllowedResolutions );
aWriteStream.WriteInt32L( iResolutionWidth );
aWriteStream.WriteInt32L( iResolutionHeight );
aWriteStream.WriteUint32L( iAllowedFrameRates );
aWriteStream.WriteUint32L( iClockRate );
aWriteStream.WriteReal64L( iReceiveFrameRate );
MceSerial::EncodeL( iConfigKey, aWriteStream );
aWriteStream.WriteUint32L( iEncodingDecodingDevice.iUid );
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::UpdateL
// -----------------------------------------------------------------------------
//
void CMceComVideoCodec::UpdateL( CMceComCodec& aCodec )
{
CMceComCodec::UpdateL( aCodec );
CMceComVideoCodec& codec = static_cast<CMceComVideoCodec&>( aCodec );
iMaxBitRate = codec.iMaxBitRate;
iAllowedResolutions = codec.iAllowedResolutions;
iAllowedFrameRates = codec.iAllowedFrameRates;
if ( IS_RECEIVESTREAM( iStream ) )
{
iFrameRate = codec.iFrameRate;
iResolutionWidth = codec.iResolutionWidth;
iResolutionHeight = codec.iResolutionHeight;
iClockRate = codec.iClockRate;
}
else
{
SetConfigKeyL( codec.iConfigKey );
}
iEncodingDecodingDevice = codec.iEncodingDecodingDevice;
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::Factory
// -----------------------------------------------------------------------------
//
TMceComVideoCodecFactory CMceComVideoCodec::Factory()
{
return TMceComVideoCodecFactory();
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::SetMaxBitrate
// -----------------------------------------------------------------------------
//
TInt CMceComVideoCodec::SetMaxBitrate( TUint aMaxBitrate )
{
if ( aMaxBitrate )
{
iMaxBitRate = aMaxBitrate;
return KErrNone;
}
else
{
return KErrArgument;
}
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::GetMaxBitRate
// -----------------------------------------------------------------------------
//
TUint CMceComVideoCodec::GetMaxBitRate()
{
return iMaxBitRate > 0 ? iMaxBitRate : iBitrate;
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::CompareSdpIndex
// -----------------------------------------------------------------------------
//
TInt CMceComVideoCodec::CompareSdpIndex(
const CMceComVideoCodec& aIndex1,
const CMceComVideoCodec& aIndex2 )
{
// NOTE: if zero (equals) is returned from here, order is strangely anyway
// changed. Returning positive value if indexes are equal is for avoiding
// this quirk.
if ( aIndex1.iCodecSdpIndex >= aIndex2.iCodecSdpIndex )
{
return (1);
}
else if ( aIndex1.iCodecSdpIndex < aIndex2.iCodecSdpIndex )
{
return (-1);
}
else
{
return (0);
}
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::SetConfigKeyL
// -----------------------------------------------------------------------------
//
TBool CMceComVideoCodec::SetConfigKeyL( HBufC8* aConfigKey )
{
TBool updated( EFalse );
if ( IsConfigKeyValid( aConfigKey ) )
{
// Set key only if none exists or new key differs from existing one
if ( !iConfigKey || ( iConfigKey->Compare( *aConfigKey ) != 0 ) )
{
HBufC8* configKey = aConfigKey->AllocL();
delete iConfigKey;
iConfigKey = configKey;
updated = ETrue;
}
}
return updated;
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::IsConfigKeyValid
// -----------------------------------------------------------------------------
//
TBool CMceComVideoCodec::IsConfigKeyValid() const
{
return IsConfigKeyValid( iConfigKey );
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::IsConfigKeyValid
// -----------------------------------------------------------------------------
//
TBool CMceComVideoCodec::IsConfigKeyValid( HBufC8* aConfigKey )
{
return ( aConfigKey && aConfigKey->Length() > 0 );
}
#ifdef MCE_COMMON_SERVER_SIDE
// -----------------------------------------------------------------------------
// CMceComVideoCodec::operator=
// -----------------------------------------------------------------------------
//
/*lint -e1539 */
CMceComCodec& CMceComVideoCodec::operator=( CMccCodecInformation& aMccCodec )
{
iPayloadType = aMccCodec.PayloadType();
iBitrate = aMccCodec.Bitrate();
iAllowedBitrates = aMccCodec.AllowedBitrates();
iCodecMode = aMccCodec.CodecMode();
iFourCC = aMccCodec.FourCC();
iFrameSize = aMccCodec.FrameSize();
iFrameRate = aMccCodec.Framerate();
iMaxBitRate = aMccCodec.MaxBitrate();
iResolutionWidth = aMccCodec.FrameWidth();
iResolutionHeight = aMccCodec.FrameHeight();
iClockRate = aMccCodec.SamplingFreq();
HBufC8* configKey = NULL;
TRAPD( err, configKey = aMccCodec.ConfigKeyL() );
if ( !err )
{
TRAP_IGNORE( SetConfigKeyL( configKey ) )
}
delete configKey;
iEncodingDecodingDevice = aMccCodec.PreferredEncodingDecodingDevice();
return *this;
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::DoMccDecodeL
// -----------------------------------------------------------------------------
//
void CMceComVideoCodec::DoMccDecodeL( CMccCodecInformation& aMccCodec )
{
// copy values, which are not explicitely in SDP, from mcc codec
iClockRate = aMccCodec.SamplingFreq();
iResolutionWidth = aMccCodec.FrameWidth();
iResolutionHeight = aMccCodec.FrameHeight();
iMaxBitRate = aMccCodec.MaxBitrate();
HBufC8* configKey = aMccCodec.ConfigKeyL();
CleanupStack::PushL( configKey );
SetConfigKeyL( configKey );
CleanupStack::PopAndDestroy( configKey );
iEncodingDecodingDevice = aMccCodec.PreferredEncodingDecodingDevice();
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::DoMccEncodeL
// -----------------------------------------------------------------------------
//
void CMceComVideoCodec::DoMccEncodeL( CMccCodecInformation& aMccCodec,
CMceSrvStream& aStream )
{
User::LeaveIfError( aMccCodec.SetSamplingFreq( iClockRate ) );
User::LeaveIfError( aMccCodec.SetFrameWidth( iResolutionWidth ) );
User::LeaveIfError( aMccCodec.SetFrameHeight( iResolutionHeight ) );
User::LeaveIfError( aMccCodec.SetMaxBitrate( iMaxBitRate ) );
User::LeaveIfError( aMccCodec.SetAverageBitrate( iBitrate ) );
User::LeaveIfError( aMccCodec.SetFramerate( iFrameRate ) );
if ( IsConfigKeyValid() )
{
aMccCodec.SetConfigKeyL( *iConfigKey );
}
if ( aStream.Source().Data().iType == KMceRTPSource )
{
CMceComRtpSource& rtpSource =
static_cast<CMceComRtpSource&> ( aStream.Source().Data() );
User::LeaveIfError(
aMccCodec.SetJitterBufInactivityTimeOut( rtpSource.iInactivityTimer ) );
User::LeaveIfError(
aMccCodec.SetJitterBufThreshold( rtpSource.iBufferTreshold ) );
User::LeaveIfError(
aMccCodec.SetJitterBufBufferLength( rtpSource.iBufferLength ) );
}
aMccCodec.SetPreferredEncodingDecodingDevice(iEncodingDecodingDevice);
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::DoMccValidateL
// -----------------------------------------------------------------------------
//
CMceComCodec* CMceComVideoCodec::DoMccValidateL( CMccCodecInformation& aMccCodec,
CMceSrvStream& aStream,
TMceNegotiationRole aRole )
{
// TBD: validate frame width and height
// Explicitly call default implementation of DoMccValidateL in base class
// to enable the check for codecMode
return CMceComCodec::DoMccValidateL( aMccCodec, aStream, aRole );
}
// -----------------------------------------------------------------------------
// CMceComAudioCodec::DoMccRequireSignalling
// -----------------------------------------------------------------------------
//
TInt CMceComVideoCodec::DoMccRequireSignalling(
const CMceSrvStream& aStream,
const CMccCodecInformation& aMccCurentCodec,
const CMccCodecInformation& aMccUpdateCodec ) const
{
TInt action = KMceNoSignalling;
if ( aStream.StreamType() == CMceComMediaStream::EReceiveStream ||
aStream.StreamType() == CMceComMediaStream::EReceiveOnlyStream )
{
if ( aMccCurentCodec.Framerate() != aMccUpdateCodec.Framerate() )
{
action = KMceRequiresSignalling;
}
}
if ( aMccCurentCodec.FrameWidth() != aMccUpdateCodec.FrameWidth() ||
aMccCurentCodec.FrameHeight() != aMccUpdateCodec.FrameHeight() )
{
action = KMceRequiresSignalling;
}
return action;
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::DoMccAdjustL
// -----------------------------------------------------------------------------
//
void CMceComVideoCodec::DoMccAdjustL( CMccCodecInformation& aMccCodec,
CMceSrvStream& aStream )
{
if( aStream.Data().iStreamType == CMceComMediaStream::ESendStream ||
aStream.Data().iStreamType == CMceComMediaStream::ESendOnlyStream )
{
User::LeaveIfError( aMccCodec.SetFramerate( iFrameRate ) );
User::LeaveIfError( aMccCodec.SetAverageBitrate( iBitrate ) );
}
User::LeaveIfError( aMccCodec.SetFrameWidth( iResolutionWidth ) );
User::LeaveIfError( aMccCodec.SetFrameHeight( iResolutionHeight ) );
}
// -----------------------------------------------------------------------------
// CMceComVideoCodec::DoSetDefaultFmtpAttributeL
// -----------------------------------------------------------------------------
//
void CMceComVideoCodec::DoSetDefaultFmtpAttributeL()
{
// NOP
}
#endif// MCE_COMMON_SERVER_SIDE