/*
* 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 CMCEMEDIASTREAM_H
#define CMCEMEDIASTREAM_H
// INCLUDES
#include <e32base.h>
// DATA TYPES
typedef TUint TMceMediaType;
// FORWARD DECLARATIONS
class CMceComMediaStream;
class TMceFactory;
class TMceMediaStreamFactory;
class RWriteStream;
class RReadStream;
class CDesC8Array;
class CMceSession;
class TMceIds;
class TMceEvent;
class TMceMediaId;
class CMceManager;
class CMceSession;
class CMceMediaSource;
class CMceMediaSink;
class MMceComSerializationContext;
class MDesC8Array;
// CLASS DECLARATION
/**
* Base class for MCE media streams.
*
* MCE Media stream represents stream of data negotiated between two terminals.
* Streams may transfer any data.
*
* Enabling or disabling of a stream is not a local operation, but it requires
* always signalling. Thus, these operation require always to be completed by
* calling CMceSession::UpdateL() function.
*
* @lib mceclient.lib
*/
class CMceMediaStream : public CBase
{
public: // Stream states
enum TState
{
EUninitialized, // Stream is created
EInitialized, // Stream is initialized
EBuffering, // Stream is buffering
EIdle, // Stream is not receiving RTP
EStreaming, // Stream is streaming
EDisabled, // Stream is explicitly disabled
ENoResources, // Stream has no needed resources to stream
ETranscodingRequired, // Stream requires non-realtime transcoding
ETranscoding // Stream is transcoding in non-realtime
};
public: // Destructor
/**
* Destructor.
*/
IMPORT_C ~CMceMediaStream();
public: // Functions
/**
* Gets the state of the stream.
* @return the current state of the stream
*/
IMPORT_C CMceMediaStream::TState State() const;
/**
* Returns the type of the stream.
* @return The type of the stream.
*/
IMPORT_C TMceMediaType Type() const;
/**
* Configures media stream by updating SDP media lines.
* In order to get complete update, whole session must be
* updated causing sending of re-invite.
* @param aMediaSDPLines, application specific SDP media lines for
* the stream. Ownership is transferred.
*/
IMPORT_C void SetMediaAttributeLinesL( CDesC8Array* aMediaSDPLines );
/**
* Gets attribute lines of the media.
* @return array of media attribute lines, owneship is transferred.
*/
IMPORT_C MDesC8Array* MediaAttributeLinesL();
/**
* Sets local media port
* @param aLocalMediaPort, local port for the media
*/
IMPORT_C void SetLocalMediaPortL(TUint aLocalMediaPort);
/**
* Gets the local media port.
* @return Local port used for media.
*/
IMPORT_C TUint LocalMediaPort() const;
/**
* Gets the session this stream belongs to, if exists. The
* ownership is not transfered.
* @return Session object
*/
IMPORT_C CMceSession* Session() const;
public: // Local stream control
/**
* Enables streaming explicitly.
*/
virtual void EnableL();
/**
* Disables streaming explicitly.
*/
virtual void DisableL();
/**
* Returns the state of the stream.
* @return ETrue if enabled, EFalse if disabled.
*/
IMPORT_C TBool IsEnabled() const;
public: // Source and sink functions
/**
* Adds source to the stream. CMceMediaStream can only
* have one source at a time. Ownership of passed source is transferred.
* However, the same source can be also passed to other streams resulting
* that streams share ownership of the source. Passing NULL source will
* remove source from stream.
* In some cases the source might contain a codec. The codec is derived
* to the stream when such source is added to the stream.
* Derived codec will get automatically highest preference.
* @param aSource source to be added to the stream; ownership is
* transferred
*/
IMPORT_C void SetSourceL( CMceMediaSource* aSource );
/**
* Adds sink to the stream. CMceMediaStream can have
* many sinks at a time. Ownership of passed sink is transferred.
* However, the same sink can be also passed to other streams resulting
* that streams share ownership of the sink.
* @param aSink sink to be added to the stream; ownership is transferred
*/
IMPORT_C void AddSinkL( CMceMediaSink* aSink );
/**
* Gets source of the stream. Returns NULL if source is not set.
* @return source of the stream; ownership is not transferred
*/
IMPORT_C CMceMediaSource* Source() const;
/**
* Gets array of sinks of the stream.
* @return array of sinks
*/
IMPORT_C const RPointerArray<CMceMediaSink>& Sinks() const;
/**
* Removes sink from the stream.
* @post aSink cannot be used anymore and contents of
* previously returned sink array (CMceMediaStream::Sinks())
* are not anymore valid
* @param aSink sink to be removed from the stream
*/
IMPORT_C void RemoveSinkL( CMceMediaSink& aSink );
public: // Binding opposite way stream
/**
* Binds opposite direction stream to this stream.
* @param aStream another stream to be bind to the stream;
* ownership is transferred
*/
IMPORT_C void BindL( CMceMediaStream* aStream );
/**
* Gets opposite direction stream of this stream.
* @return opposite direction stream
*/
IMPORT_C CMceMediaStream& BoundStreamL() const;
/**
* Checks if opposite direction stream is set.
* @return ETrue if opposite direction stream is set;
* otherwise EFalse
*/
IMPORT_C TBool BoundStream() const;
public: //internal
/**
* Checks if this is binder (biding owner)
* @return ETrue if this is binder (biding owner)
*/
TBool Binder() const;
/**
* Initializes
* @param aParent the parent
*/
virtual void InitializeL( CMceSession& aParent );
/**
* Initializes
* @param aManager the manager. Ownership is NOT transferred
*/
virtual void InitializeL( CMceManager* aManager );
protected:
/**
* C++ default constructor.
*/
CMceMediaStream();
private:
/**
* Handles event
* @param aEvent the event
* @return status, if event was consumed or not or object needs update
*/
TInt HandleEvent( TMceEvent& aEvent );
/**
* one-way bind
* @param aStream another stream to be bind to the stream.
*/
void DoBindL( CMceMediaStream* aStream );
/**
* Deletes sink
* @param aIndex index of sink in the array
*/
void DeleteSink( TInt aIndex );
/**
* Deletes source
*/
void DeleteSource();
protected: // NOT owned data
/**
* session
*/
CMceSession* iSession;
protected: // owned data
/**
* linked stream. Owned if iLinkOwner is ETrue
*/
CMceMediaStream* iLinkedStream;
public: // stub data
/**
* source
*/
CMceMediaSource* iSource;
/**
* sinks
*/
RPointerArray<CMceMediaSink> iSinks;
TState iState;
TMceMediaType iType;
TBool iLinkOwner;
TBool iIsEnabled;
TUint iLocalMediaPort;
CDesC8Array* iMediaSDPLines;
};
#endif