diff -r 000000000000 -r 1bce908db942 multimediacommsengine/mmceshared/inc/mcecommediastream.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommsengine/mmceshared/inc/mcecommediastream.h Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,707 @@ +/* +* 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: +* +*/ + + + + +#ifndef CMCECOMMEDIASTREAM_H +#define CMCECOMMEDIASTREAM_H + +#include +#include +#include +#include +#include "mcemediastream.h" +#include "mcedefs.h" +#include "mceclientserver.h" +#include "mcecomserializable.h" + + +#ifdef MCE_COMMON_SERVER_SIDE + +#include +#include + +class TMceMccComEvent; +class CMceMediaManager; + +#endif//MCE_COMMON_SERVER_SIDE + + +class TMceComFactory; +class TMceComMediaStreamFactory; +class TMceComEvent; +class CMceComSession; +class TMceMccComEvent; +class CMceComCodec; +class CMceComMediaSource; +class CMceComMediaSink; +class MMceComSerializationContext; +class TMcePreconditions; +class CSdpMediaField; + +#define IS_SENDSTREAM( stream )\ + ( ( stream )->iStreamType == CMceComMediaStream::ESendStream ||\ + ( stream )->iStreamType == CMceComMediaStream::ESendOnlyStream ) + +#define IS_RECEIVESTREAM( stream )\ + ( ( stream )->iStreamType == CMceComMediaStream::EReceiveStream ||\ + ( stream )->iStreamType == CMceComMediaStream::EReceiveOnlyStream ) + + +const TBool KMceNoEndpointAdjustment = EFalse; +const TBool KMceEndpointAdjustment = ETrue; +const TBool KMceRoleAnswerer = ETrue; +const TBool KMceRoleOfferer = EFalse; + + +/** + * + * + * @lib + */ +class CMceComMediaStream: public CBase, + public MMceComSerializable + + { + + +public: // Destructor + + enum TStreamType + { + ELocalStream, + ESendOnlyStream, + EReceiveOnlyStream, + ESendStream, + EReceiveStream + }; + +public: // Destructor + + + /** + * Destructor. + */ + ~CMceComMediaStream(); + +public: // Source and sink functions + + /** + * Adds source to the stream. + * @param aSource source to be added to the stream. + */ + void SetSourceL( CMceComMediaSource* aSource ); + + /** + * Adds sink to the stream. + * @param aSink sink to be added to the stream. + */ + void AddSinkL( CMceComMediaSink* aSink ); + + /** + * Deletes sink + * @param aIndex index of sink in the array + */ + void DeleteSink( TInt aIndex ); + + /** + * Removes codec from stream + * @param aCodec the codec + */ + virtual void RemoveCodecL( CMceComCodec* aCodec ) = 0; + + /** + * Clears list of codecs and deletes each codec in it. + */ + virtual void DestroyCodecs() = 0; + + /** + * Searches for codec matching with input codec instance or sdp name + * @param aCodec the search term + * @return matching codec or NULL if not found + */ + virtual CMceComCodec* FindCodecL( CMceComCodec& aCodec ) = 0; + + /** + * Adds codec to the stream. + * @param aCodec codec to be added to the stream. + * Ownership is transferred. + */ + virtual void AddCodecL( CMceComCodec* aCodec ) = 0; + + /** + * Gets source of the stream. Returns null is source not set. + * @return source of the stream. Ownership is not transferred. + */ + CMceComMediaSource* Source(); + + /** + * Gets array of sinks of the stream. + * @return array of sinks. + */ + RPointerArray& Sinks(); + + virtual void ReorderCodecs() = 0; + + +public: // Binding opposite way stream + + /** + * Binds opposite direction stream to this stream. + * @param aStream another stream to be bind to the stream. + */ + void BindL( CMceComMediaStream* aStream ); + + /** + * Gets opposite direction stream of this stream. + * @return opposite direction stream. + */ + CMceComMediaStream& BoundStreamL(); + + /** + * Checks if opposite direction stream is set. + * @return ETrue if opposite direction stream is set. + */ + TBool BoundStream() const; + + /** + * Checks if this is binder (biding owner) + * @return ETrue if this is binder (biding owner) + */ + TBool Binder() const; + + /** + * Gives 'main' stream + * @return 'main' stream + */ + CMceComMediaStream& operator()(); + + /** + * Gives 'main' stream + * @return 'main' stream + */ + const CMceComMediaStream& operator()() const; + + /** + * Gives send stream + * @return send stream + */ + CMceComMediaStream* SendStream(); + + /** + * Gives receive stream + * @return receive stream + */ + CMceComMediaStream* ReceiveStream(); + + /** + * Gives offer stream + * @return offer stream + */ + CMceComMediaStream* OfferStream(); + + /** + * Gives answer stream + * @return answer stream + */ + CMceComMediaStream* AnswerStream(); + + /** + * Gives sdp index + * @return sdp index + */ + TInt& SdpIndex(); + + +public: //from MMceComSerializable + + /** + * Returns serialization id + * @return serialization id + */ + TUint64 SerializationId() const; + + /** + * Internalizes flat data + * @param aReadStream read stream + */ + void InternalizeFlatL( RReadStream& aReadStream ); + + /** + * Externalizes flat data + * @param aWriteStream write stream + */ + void ExternalizeFlatL( RWriteStream& aWriteStream ); + + /** + * Internalizes + * @param aSerCtx context for serialization + */ + void InternalizeL( MMceComSerializationContext& aSerCtx ); + + /** + * Externalizes + * @param aSerCtx context for serialization + */ + void ExternalizeL( MMceComSerializationContext& aSerCtx ); + + +public: //serialization helpers + + /** + * Factory + * @return factory + */ + TMceComFactory BaseFactory(); + + /** + * Factory + * @return factory + */ + static TMceComMediaStreamFactory Factory(); + + /** + * Adds source, during serialization, to the stream. + * @param aSerCtx serialization context + */ + void SetSourceL( MMceComSerializationContext& aSerCtx ); + + /** + * Adds sink, during serialization, to the stream. + * @param aSerCtx serialization context + */ + void AddSinkL( MMceComSerializationContext& aSerCtx ); + + +public:// new Functions + + /** + * ID + * @return ID + */ + TMceMediaId Id() const; + + /** + * Parent object + * @return Parent object + */ + CMceComSession* Session() const; + + + /** + * Initializes + * @param aParent the parent + */ + virtual void InitializeL( CMceComSession& aParent ); + + /** + * Traversal event handler + * @param aEvent the event + * @return status, if event was consumed or not or object needs update + */ + virtual TInt EventReceivedL( TMceComEvent& aEvent ); + + /** + * Updates + * @param aStream new stream + */ + virtual void UpdateL( CMceComMediaStream& aStream ); + + /** + * Clones whole stream object + * @return cloned stream object + */ + virtual CMceComMediaStream* CloneL() = 0; + + +public:// new Functions + + /** + * Returns ETrue, if enabled + * @return ETrue, if enabled + */ + virtual TBool IsEnabled(); + + /** + * Sets remote media port + * @param aPort remote media port + */ + void SetRemoteMediaPort( TUint aPort ); + + /** + * Sets remote rtcp media address + * @param aAddr remote rtcp media address + */ + void SetRemoteRtcpMediaAddrL( TDesC16& aAddr ); + + /** + * Sets local media port + * @param aPort local media port + */ + void SetLocalMediaPort( TUint aPort ); + + /** + * Gets remote media port + * @return remote media port + */ + TUint RemoteMediaPort() const; + + /** + * Gets local media port + * @return local media port + */ + TUint LocalMediaPort() const; + + /** + * Sets remote media port + * @param aPort remote media port + */ + void SetRemoteRtcpMediaPort( TUint aPort ); + + /** + * Checks whether remote media port has changed + * @return ETrue if port has changed, otherwise return EFalse + */ + TBool RemoteMediaPortChanged( TUint aNewPort ); + + + /** + * Checks whether remote RTCP address, and port has changed + * @return ETrue if port has changed, otherwise return EFalse + */ + TBool CMceComMediaStream::RemoteRTCPAddressChanged( TUint aNewPort, TInetAddr aAddr ); + + + /** + * Stores remote port. + * @param aIgnore, ETrue if remote port comparison should be ignored + */ + void SetIgnoreRemotePort( TBool aIgnore ); + + TBool& DowngradedEndpoints(); + +#ifdef MCE_COMMON_SERVER_SIDE + +public:// new (virtual) Functions + + /** + * Called when stream has been decoded + * @param aDecodedOffer is offer decoded + */ + void DecodedL( TBool aRoleAnswerer ); + + /** + * Synchronizes stream's codecs. + * @param aRoleAnswerer is answerer + */ + virtual void SynchronizeL( TBool aRoleAnswerer ) = 0; + + /** + * Update default codec to reflect current negotiation + */ + virtual void UpdateDefaultCodecL() = 0; + + /** + * Prepares + */ + virtual void PrepareL() = 0; + + /** + * Return mcc stream type + * @return mcc stream type + */ + virtual TInt MccStreamType() const = 0; + + /** + * Return mcc link type + * @return mcc link type + */ + virtual TInt MccLinkType() const = 0; + + /** + * Handles event received from mcc + * @param aEvent the event from mcc + */ + virtual void EventReceived( TMceMccComEvent& aEvent ); + +public:// new Functions + + /** + * Sets state + * @param aEvent the event from mcc + */ + void SetState( TMceMccComEvent& aEvent ); + + /** + * Sets link id + * @param aLinkId the link id + */ + void SetLinkId( TUint32 aLinkId ); + + /** + * Gets direction + * @return direction + */ + TInt Direction(); + + /** + * Sets direction + * @param aDirection direction + * @param aEndpointAdjustment should endpoints follow + */ + void SetDirection( TInt aDirection, TBool aEndpointAdjustment = KMceEndpointAdjustment ); + + /** + * Sets direction. Leaves if not allowed + * @param aDirection direction + */ + void SetDirectionL( TInt aDirection ); + + /** + * Sets stream enabled/disabled + * @param aEnable if ETrue stream and sinks/source + * is set enabled + * @param aEndpointAdjustment if endpoints follow + */ + void Enable( TBool aEnable, TBool aEndpointAdjustment ); + + /** + * Gets SDP stream type + * @return SDP stream type + */ + TInt SdpStreamType(); + + /** + * Gets or creates preconditions + * @param aModifier mce preconditon modifier + * @param aMediaLine media line + * @return preconditions + */ + TMcePreconditions* PreconditionsL( TMceSessionModifier aModifier, + CSdpMediaField* aMediaLine = NULL ); + + /** + * Gets preconditions + * @return preconditions + */ + const RPointerArray& Preconditions() const ; + + /** + * CopyPrecondition parameters + * @param aModifier mce preconditon modifier + * @return void + */ + void CopyPreconditionL( TMceSessionModifier aModifier ); + + + /** + * Merges with stream + */ + void Merge( CMceComMediaStream& aMergeWith ); + +#endif//MCE_COMMON_SERVER_SIDE + + /** + * Gets empty sink + * @return empty sink + */ + CMceComMediaSink& EmptySinkL(); + + /** + * Gets empty source + * @return empty source + */ + CMceComMediaSource& EmptySourceL(); + + + /** + * Checks whether RTCP should be used. + * return ETrue, if the source and all the sinks indicate RTCP usage, + * otherwise EFalse. + */ + TBool UseRtcp() const; + +protected: + + + /** + * C++ default constructor. + * @param type of stream + */ + CMceComMediaStream( TMceMediaType aType ); + + /** + * second-phase constructor + */ + void ConstructL(); + + /** + * second-phase copy constructor + */ + void ConstructL( CMceComMediaStream& aStream ); + + +private: // methods + + /** + * one-way bind + * @param aStream another stream to be bind to the stream. + */ + void DoBind( CMceComMediaStream* aStream ); + + /** + * Deletes source + */ + void DeleteSource(); + + /** + * Checks whether RTCP should be used. + * return ETrue, if the source and all the sinks indicate RTCP usage, + * otherwise EFalse. + */ + TBool DoUseRtcp() const; + +public: // Owned serialized Data + + /** + * ID + */ + TMceMediaId iID; + + /** + * type + */ + TMceMediaType iType; + + /** + * state, enabled or disabled + */ + TBool iIsEnabled; + + /** + * Local port + */ + TUint iLocalMediaPort; + + /** + * Remote port + */ + TUint iRemoteMediaPort; + + /** + * Remote RTCP IP-address (IPv4 or IPv6) + */ + TInetAddr iRemoteRtcpAddress; + + /** + * Remote RTCP port, if 0 then use RTP port + 1 + */ + TUint iRemoteRtcpPort; + + /** + * local sdp media lines + */ + CDesC8Array* iLocalMediaSDPLines; + + /** + * remote sdp media lines + */ + CDesC8Array* iRemoteMediaSDPLines; + + /** + * stream type + */ + TStreamType iStreamType; + + /** + * stream state + */ + CMceMediaStream::TState iState; + + /** + * ignore remote port comparison + */ + TBool iIgnoreRemotePort; + + /** + * does this owns the link + */ + TBool iLinkOwner; + + /** + * linked stream. Owned if iLinkOwner is ETrue + */ + CMceComMediaStream* iLinkedStream; + + /** + * source + */ + CMceComMediaSource* iSource; + + /** + * sinks + */ + RPointerArray iSinks; + + /** + * sdp index + */ + TInt iSdpIndex; + + /** + * link id + */ + TUint32 iLinkId; + + /** + * preconditions + */ + RPointerArray iPreconditions; + + /** + * empty source + */ + CMceComMediaSource* iEmptySource; + + /** + * empty sink + */ + CMceComMediaSink* iEmptySink; + + +protected: // NOT owned data + + /** + * session + */ + CMceComSession* iSession; + +private: + + TBool iDowngradedEnpoints; + +#ifdef EUNIT_TEST + friend class UT_CMceMediaSdpCodec; + friend class UT_CMceAudioSdpCodec; + friend class UT_CMceVideoSdpCodec; + +#endif + }; + + +#endif \ No newline at end of file