/*
* 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 FILES
#include <e32base.h>
#include <e32std.h>
#include <e32def.h>
#include <stringpool.h>
#include <sdpdocument.h>
#include <sdpcodecstringconstants.h>
#include <sdpcodecstringpool.h>
#include <sdpmediafield.h>
#include <sdpattributefield.h>
#include <sdprtpmapvalue.h>
#include <sdpfmtattributefield.h>
#include <sdporiginfield.h>
#include "mcemediadefs.h"
#include "mceaudiosdpcodec.h"
#include "mcecomaudiostream.h"
#include "mceaudiostream.h"
#include "mcecomaudiocodec.h"
#include "mcemediadefs.h"
#include "mcecomfactory.h"
#include "mcemmlogs.h"
#include "mcecomrtpsource.h"
#include "mcecomspeakersink.h"
#include "mcecommicsource.h"
#include "mcecomrtpsink.h"
#include "mcedefs.h"
// ================= MEMBER FUNCTIONS =======================
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::NewL
// -----------------------------------------------------------------------------
//
CMceAudioSdpCodec* CMceAudioSdpCodec::NewL()
{
RStringF audio = MCE_SDP_STRING_AUDIOL();
CMceAudioSdpCodec* self = new (ELeave) CMceAudioSdpCodec( audio );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::CMceAudioSdpCodec
// -----------------------------------------------------------------------------
//
CMceAudioSdpCodec::CMceAudioSdpCodec( RStringF aMedia )
: CMceMediaSdpCodec( aMedia )
{
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::~CMceAudioSdpCodec
// -----------------------------------------------------------------------------
//
CMceAudioSdpCodec::~CMceAudioSdpCodec()
{
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::Encodes
// -----------------------------------------------------------------------------
//
TBool CMceAudioSdpCodec::Encodes( const CMceComMediaStream& aStream ) const
{
return aStream.iStreamType != CMceComMediaStream::ELocalStream &&
aStream.iType == KMceAudio;
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::CodecsL
// -----------------------------------------------------------------------------
//
const RPointerArray<CMceComCodec>& CMceAudioSdpCodec::CodecsL( CMceComMediaStream& aStream ) const
{
__ASSERT_ALWAYS( aStream.iType == KMceAudio, User::Leave( KErrArgument ) );
MCE_DEFINE_AUDIO( stream, aStream );
return reinterpret_cast< const RPointerArray< CMceComCodec >& >( stream.Codecs() );
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::EncodeRtpmapAttributeLC
// -----------------------------------------------------------------------------
//
CSdpFmtAttributeField* CMceAudioSdpCodec::EncodeRtpmapAttributeLC( CMceComCodec& aCodec ) const
{
MCEMM_DEBUG( "CMceAudioSdpCodec::EncodeRtpmapAttributeLC(), Entry" )
MCE_DEFINE_AUDIO_CODEC( codec, aCodec );
CSdpFmtAttributeField* rtpmapAttribute = NULL;
TUint payloadType = codec.iPayloadType;
TPtrC8 codecName = codec.iSdpName;
TUint samplingFreq = codec.iSamplingFreq;
// Create rtpmap field for current codec
rtpmapAttribute = EncodeRtpMapFieldsL( payloadType,
codecName,
samplingFreq,
KMceSdpOptionalEncodingParam );
CleanupStack::PushL( rtpmapAttribute );
MCEMM_DEBUG_SVALUE( "encoded rtpmap", rtpmapAttribute->Value() )
MCEMM_DEBUG( "CMceAudioSdpCodec::EncodeRtpmapAttributeLC(), Exit" )
return rtpmapAttribute;
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::EncodeMediaAttributesL
// -----------------------------------------------------------------------------
//
void CMceAudioSdpCodec::EncodeMediaAttributesL( CMceComCodec& aCodec,
CSdpMediaField& aMediaLine,
CSdpFmtAttributeField& aRtpmap ) const
{
MCEMM_DEBUG( "CMceAudioSdpCodec::EncodeMediaAttributesL(), Entry" )
MCE_DEFINE_AUDIO_CODEC( codec, aCodec );
if ( aCodec.Stream()->ReceiveStream() )
{
if ( codec.iPTime &&
codec.iMaxPTime &&
!FindAttribute( SdpCodecStringConstants::EAttributePtime, aMediaLine ) )
{
RStringF attributePtime = SDP_STRING( SdpCodecStringConstants::EAttributePtime );
RStringF attributeMaxPtime = SDP_STRING( SdpCodecStringConstants::EAttributeMaxptime );
MCE_DEFINE_DECSTR( ptime, codec.iPTime )
MCE_DEFINE_DECSTR( maxptime, codec.iMaxPTime )
CSdpAttributeField* ptimeLine =
CSdpAttributeField::NewLC( attributePtime, ptime );
CSdpAttributeField* maxptimeLine =
CSdpAttributeField::NewLC( attributeMaxPtime, maxptime );
MCEMM_DEBUG_SVALUE( "encoded ptime", ptime )
MCEMM_DEBUG_SVALUE( "encoded maxptime", maxptime )
aMediaLine.AttributeFields().AppendL( ptimeLine );
// this creates dependency between ptime and payload type
ptimeLine->AssignTo( aRtpmap );
CleanupStack::Pop( maxptimeLine );
aMediaLine.AttributeFields().AppendL( maxptimeLine );
// this creates dependency between maxptime and payload type
maxptimeLine->AssignTo( aRtpmap );
CleanupStack::Pop( ptimeLine );
}
}
MCEMM_DEBUG( "CMceAudioSdpCodec::EncodeMediaAttributesL(), Exit" )
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::DecodeMediaAttributesL
// -----------------------------------------------------------------------------
//
void CMceAudioSdpCodec::DecodeMediaAttributesL(
CSdpMediaField& aMediaLine,
CMceComCodec& aCodec,
CSdpFmtAttributeField& /*aRtpmap*/ ) const
{
MCEMM_DEBUG( "CMceAudioSdpCodec::DecodeMediaAttributesL(), Entry ")
MCE_DEFINE_AUDIO_CODEC( codec, aCodec );
if ( aCodec.Stream()->SendStream() )
{
RPointerArray<CSdpAttributeField>& attrfields =
aMediaLine.AttributeFields();
// Packet times are negotiated at session or media line level and thus
// several codecs share common packet time values.
for ( TInt index = 0; index < attrfields.Count(); index++ )
{
CSdpAttributeField* attrfield = attrfields[ index ];
RStringF attribute;
attribute = attrfield->Attribute();
if ( attribute ==
SDP_STRING( SdpCodecStringConstants::EAttributePtime ) )
{
TUint ptime = ConvertDesToUintL( attrfield->Value() );
codec.SetPTime( ptime );
MCEMM_DEBUG_DVALUE( "decoded ptime", ptime )
}
else if ( attribute ==
SDP_STRING( SdpCodecStringConstants::EAttributeMaxptime ) )
{
TUint maxptime = ConvertDesToUintL( attrfield->Value() );
codec.SetMaxPTime( maxptime );
MCEMM_DEBUG_DVALUE( "decoded maxptime", maxptime )
}
else
{
// do not mind other attributes
}
}
}
MCEMM_DEBUG_DVALUES( "exit ptime", codec.iPTime,
"maxptime", codec.iMaxPTime )
MCEMM_DEBUG("CMceAudioSdpCodec::DecodeMediaAttributesL(), Exit ")
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::CreateStreamLC
// -----------------------------------------------------------------------------
//
CMceComMediaStream* CMceAudioSdpCodec::CreateStreamLC( TInt aType ) const
{
MCEMM_DEBUG( "CMceAudioSdpCodec::CreateStreamLC(), Entry" )
CMceComAudioStream* audiostream = NULL;
if( aType == SdpCodecStringConstants::EAttributeSendonly )
{
// downlink
MCEMM_DEBUG( "create downlink" )
audiostream = CreateDownlinkStreamL();
}
else if( aType == SdpCodecStringConstants::EAttributeRecvonly )
{
// uplink
MCEMM_DEBUG( "create uplink" )
audiostream = CreateUplinkStreamL();
}
else
{
// sendrcv
// create two way stream
// create downlink
MCEMM_DEBUG( "create two-way stream" )
audiostream = CreateDownlinkStreamL();
CleanupStack::PushL( audiostream );
// create bounded uplink
CMceComAudioStream *boundUplink = CreateUplinkStreamL();
CleanupStack::PushL( boundUplink );
audiostream->BindL( boundUplink );
CleanupStack::Pop( boundUplink );
CleanupStack::Pop( audiostream );
}
CleanupStack::PushL( audiostream );
MCEMM_DEBUG( "CMceAudioSdpCodec::CreateStreamLC(), Exit" )
return audiostream;
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::UpdateStreamL
// -----------------------------------------------------------------------------
//
void CMceAudioSdpCodec::UpdateStreamL( CMceComMediaStream& aStream, TInt aDirection ) const
{
MCEMM_DEBUG( "CMceAudioSdpCodec::UpdateStreamL(), Entry ")
MCE_DEFINE_AUDIO( stream, aStream );
CMceComAudioStream* audiostream = NULL;
TInt streamType = stream.SdpStreamType();
if ( aDirection != SdpCodecStringConstants::EAttributeInactive )
{
switch( streamType )
{
case SdpCodecStringConstants::EAttributeRecvonly:
{
//if direction is changed
if ( aDirection != SdpCodecStringConstants::EAttributeSendonly )
{
MCEMM_DEBUG( "update from recvonly to send" )
MCEMM_DEBUG( "create uplink" )
audiostream = CreateUplinkStreamL();
}
break;
}
case SdpCodecStringConstants::EAttributeSendonly:
{
//if direction is changed
if ( aDirection != SdpCodecStringConstants::EAttributeRecvonly )
{
MCEMM_DEBUG( "update from sendonly to recv" )
MCEMM_DEBUG( "create downlink" )
audiostream = CreateDownlinkStreamL();
}
break;
}
case SdpCodecStringConstants::EAttributeSendrecv:
default:
{
break;
}
}
}
if ( audiostream )
{
CleanupStack::PushL( audiostream );
MCEMM_DEBUG( "cloning codecs" )
for( TInt index = 0; index < stream.CodecCount(); ++index )
{
CMceComAudioCodec* codec =
static_cast<CMceComAudioCodec*>( stream.CodecL( index )->CloneL() );
CleanupStack::PushL( codec );
MCEMM_DEBUG_SVALUE( "cloned codec", codec->iSdpName )
audiostream->AddCodecL( codec );
CleanupStack::Pop( codec );
}
stream.BindL( audiostream );
audiostream->InitializeL( *aStream.Session() );
MCEMM_DEBUG( "binded stream created" )
CleanupStack::Pop( audiostream );
}
MCEMM_DEBUG( "CMceAudioSdpCodec::UpdateStreamL(), Exit" )
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::CreateCodecLC
// -----------------------------------------------------------------------------
//
CMceComCodec* CMceAudioSdpCodec::CreateCodecLC( CSdpFmtAttributeField& aRtpmap ) const
{
MCEMM_DEBUG( "CMceAudioSdpCodec::CreateCodecLC(), Entry" )
CMceComAudioCodec* codec = NULL;
const TDesC8& payloadType = aRtpmap.Format();
const TDesC8& attributeValue = aRtpmap.Value();
TSdpRtpmapValue rtpmapValue = TSdpRtpmapValue::DecodeL( attributeValue );
TPtrC8 codecName = rtpmapValue.iEncName;
TPtrC8 clockRate = rtpmapValue.iClockrate;
TUint uintValPT = ConvertDesToUintL( payloadType );
TUint uintValCR = ConvertDesToUintL( clockRate );
if ( uintValPT > KMceMaxPTValue )
{
MCEMM_DEBUG_DVALUE("CMceAudioSdpCodec::CreateCodecLC(), invalid payloadtype value ", uintValPT )
User::Leave( KErrNotSupported );
}
if ( IsSupported( codecName ) && IsPayloadTypeSupported( codecName, uintValPT ) )
{
TMceComAudioCodecFactory factory;
codec = factory.CreateLC( codecName );
codec->iSamplingFreq = uintValCR;
codec->iPayloadType = uintValPT;
MCEMM_DEBUG_SVALUE( "created codec", codecName )
MCEMM_DEBUG_DVALUE( "sampling frequence", uintValCR )
MCEMM_DEBUG_DVALUE( "payload", uintValPT )
}
else
{
MCEMM_DEBUG_SVALUE( "not supported codec", codecName )
}
MCEMM_DEBUG( "CMceAudioSdpCodec::CreateCodecLC(), Exit" )
return codec;
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::CreateCodecLC
// -----------------------------------------------------------------------------
//
CMceComCodec* CMceAudioSdpCodec::CreateCodecLC( TUint aPayload,
CSdpMediaField& /*aMediaLine*/ ) const
{
MCEMM_DEBUG( "CMceAudioSdpCodec::CreateCodecLC( payload ), Entry" )
TMceComAudioCodecFactory factory;
CMceComAudioCodec* codec = NULL;
codec = factory.CreateCodecLC( aPayload );
if ( codec && !IsSupported( codec->iSdpName ) )
{
CleanupStack::PopAndDestroy( codec );
codec = NULL;
}
MCEMM_DEBUG( "CMceAudioSdpCodec::CreateCodecLC( payload ), Exit" )
return codec;
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::DecodeSessionMediaAttributesL
// -----------------------------------------------------------------------------
//
void CMceAudioSdpCodec::DecodeSessionMediaAttributesL( CMceComMediaStream& aStream,
CSdpDocument& aSdpDocument ) const
{
MCEMM_DEBUG( "CMceAudioSdpCodec::DecodeSessionMediaAttributesL(), Entry" )
MCE_DEFINE_AUDIO( stream, aStream );
if ( stream.SendStream() )
{
RPointerArray<CSdpAttributeField>& attrfields =
aSdpDocument.AttributeFields();
// look for the ptime and maxptime attributes, go through all
// attribute fields and apply to all codecs in the stream if found
for ( TInt index = 0; index < attrfields.Count(); index++ )
{
CSdpAttributeField* attrfield = attrfields[ index ];
RStringF attribute = attrfield->Attribute();
TInt j = 0;
if ( attribute == SDP_STRING( SdpCodecStringConstants::EAttributePtime ) )
{
MCEMM_DEBUG_SVALUE( "decoded ptime", attrfield->Value() )
for ( j = 0; j < stream.CodecCount(); j++ )
{
stream.CodecL( j )->iPTime = ConvertDesToUintL( attrfield->Value() );
}
}
else if ( attribute == SDP_STRING( SdpCodecStringConstants::EAttributeMaxptime ) )
{
MCEMM_DEBUG_SVALUE( "decoded maxptime", attrfield->Value() )
for ( j = 0; j < stream.CodecCount(); j++ )
{
stream.CodecL( j )->iMaxPTime = ConvertDesToUintL( attrfield->Value() );
}
}
}
}
MCEMM_DEBUG( "CMceAudioSdpCodec::DecodeSessionMediaAttributesL(), Exit" )
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::CreateUplinkStreamL
// -----------------------------------------------------------------------------
//
CMceComAudioStream* CMceAudioSdpCodec::CreateUplinkStreamL() const
{
MCEMM_DEBUG( "CMceAudioSdpCodec::CreateUplinkStreamL(), Entry" )
CMceComAudioStream *audiostream = CMceComAudioStream::NewL();
CleanupStack::PushL( audiostream );
// uplink
CMceComMicSource* micSource = CMceComMicSource::NewL();
CleanupStack::PushL( micSource );
micSource->InitializeL( static_cast<CMceComAudioStream&> ( *audiostream ) );
audiostream->SetSourceL( micSource );
CleanupStack::Pop( micSource );
CMceComRtpSink* rtpSink = CMceComRtpSink::NewL();
CleanupStack::PushL( rtpSink );
rtpSink->InitializeL( static_cast<CMceComAudioStream&> ( *audiostream ) );
audiostream->AddSinkL( rtpSink );
CleanupStack::Pop( rtpSink );
CleanupStack::Pop( audiostream );
MCEMM_DEBUG( "CMceAudioSdpCodec::CreateUplinkStreamL(), Exit" )
return audiostream;
}
// -----------------------------------------------------------------------------
// CMceAudioSdpCodec::CreateDownlinkStreamL
// -----------------------------------------------------------------------------
//
CMceComAudioStream* CMceAudioSdpCodec::CreateDownlinkStreamL() const
{
MCEMM_DEBUG( "CMceAudioSdpCodec::CreateDownlinkStreamL(), Entry" )
CMceComAudioStream *audiostream = CMceComAudioStream::NewL();
CleanupStack::PushL( audiostream );
// downlink
CMceComRtpSource* rtpSource = CMceComRtpSource::NewL();
CleanupStack::PushL( rtpSource );
rtpSource->InitializeL( static_cast<CMceComAudioStream&> ( *audiostream ) );
audiostream->SetSourceL( rtpSource );
CleanupStack::Pop( rtpSource );
CMceComSpeakerSink* speaker = CMceComSpeakerSink::NewL();
CleanupStack::PushL( speaker );
speaker->InitializeL( static_cast<CMceComAudioStream&> ( *audiostream ) );
audiostream->AddSinkL( speaker );
CleanupStack::Pop( speaker );
CleanupStack::Pop( audiostream );
MCEMM_DEBUG( "CMceAudioSdpCodec::CreateDownlinkStreamL(), Exit" )
return audiostream;
}