--- a/epoc32/include/rtp.h Tue Nov 24 13:55:44 2009 +0000
+++ b/epoc32/include/rtp.h Tue Mar 16 16:12:26 2010 +0000
@@ -1,1 +1,1352 @@
-rtp.h
+// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef RTP_H
+#define RTP_H
+
+#include <es_sock.h>
+
+class TRtpEvent;
+class RRtpSession;
+class RRtpSendPacket;
+class RRtpReceivePacket;
+class RRtpReceiveSource;
+class RRtpSendSource;
+class RRtpHeaderExtension;
+class RRtpCSRCs;
+class CRtpSession;
+class CRtpReceiveSource;
+class CRtpSendSource;
+class TRtpPacket;
+
+class RRtcpRRPart;
+class RRtcpSRPart;
+
+/**
+@publishedAll
+@released
+
+A set of values that defines the event types that may be handled.
+
+See all variants of the RegisterEventCallbackL() function.
+
+@see TRtpEvent
+*/
+enum TRtpEventType
+ {
+ /**
+ A special event type that is interpreted by all of
+ the RegisterEventCallbackL() set of functions to mean that the registered
+ callback function is to be called for any event except failure events.
+ */
+ ERtpAnyEvent = 0,
+
+
+ /**
+ Defines a base value for session events.
+
+ All session event types have values that are greater than this.
+ */
+ ERtpSessionEventBase = 0x100,
+
+
+ /**
+ An event type that indicates that a session-level error has occurred.
+
+ The event status is a standard Symbian OS error code.
+ The callback parameter is used to register interest in only one
+ type of error.
+ */
+ ERtpSessionFail = 0x101,
+
+
+ /**
+ An event type that indicates that a new stream has been received.
+
+ The event status is the SSRC of the stream.
+ */
+ ERtpNewSource = 0x102,
+
+
+ /**
+ An event type that indicates that an RTCP RR (Receiver Report) has been
+ received.
+
+ The event status is the SSRC of the sender.
+
+ Note - This event type has not been implemented yet.
+ */
+ ERtpNewRR = 0x103,
+
+
+ /**
+ An event type that indicates that a packet bigger than the expected maximum
+ has been received.
+
+ When this event occurs, the packet is deleted.
+ */
+ ERtpBufferOverflow = 0x104,
+
+
+ /**
+ An event type that indicates that a packet has been recived that
+ is smaller than its header.
+
+ When this event occurs, the packet is deleted.
+ */
+ ERtpUndersizedPacket = 0x105,
+
+
+ /**
+ Not an event type, but defines the upper limit for session event
+ type values.
+ */
+ ERtpSessionEventEnd = 0x1ff,
+
+
+ /**
+ Not an event type but defines a base value for send stream events.
+
+ All send stream event types have values that are greater than this.
+ */
+ ERtpSendEventBase = 0x200,
+
+
+ /**
+ An event type that indicates that an error has occurred while sending
+ a packet.
+
+ The event status is a standard Symbian OS error code. The callback parameter
+ is used only to register interest in one type of error.
+ */
+ ERtpSendFail = 0x201,
+
+
+ /**
+ An event type that indicates that a send packet operation has succeeded.
+ */
+ ERtpSendSucceeded = 0x202,
+
+
+ /**
+ Not an event type, but defines the upper limit for send stream event
+ type values.
+ */
+ ERtpSendEventEnd = 0x2ff,
+
+
+ /**
+ Not an event type but defines a base value for receive stream events.
+
+ All receive stream event types have values that are greater than this.
+ */
+ ERtpSourceEventBase = 0x300,
+
+
+ /**
+ An event type that indicates that an error has occurred.
+
+ The event status is a standard Symbian OS error code. The callback parameter
+ is used only to register interest in one type of error.
+ */
+ ERtpSourceFail = 0x301,
+
+
+ /**
+ An event type that indicates that an in-sequence packet has been received.
+ */
+ ERtpPacketReceived = 0x302,
+
+
+ /**
+ An event type that indicates that the codec has changed.
+
+ The event status is the new payload type.
+ */
+ ERtpCodecChange = 0x303,
+
+
+ /**
+ An event type that indicates that a marker packet has arrived.
+ */
+ ERtpMarker = 0x304,
+
+
+ /**
+ An event type that indicates that a misordered packet has arrived.
+ */
+ ERtpMisorder = 0x305,
+
+
+ /**
+ An event type that indicates that a dropout has been detected.
+ */
+ ERtpDropout = 0x306,
+
+
+ /**
+ An event type that indicates that a SDES (Source Description) RTCP packet
+ has been received.
+
+ For SDES events, the callback parameter is used to specify the type of
+ SDES. Use a value from TRtpSendPacketType
+
+ The event status is the SSRC of the sender.
+
+ @see RRtpSession::TRtpSendPacketType
+ */
+ ERtpSDES = 0x307,
+
+
+ /**
+ An event type that indicates that a APP (Application Defined) RTCP packet
+ has been received.
+
+ The event status is the SSRC of the sender.
+
+ */
+ ERtpAPP = 0x308,
+
+
+ /**
+ An event type that indicates that a SR (Sender Report) RTCP packet
+ has been received.
+
+ The event status is the SSRC of the sender.
+
+ */
+ ERtpSR = 0x309,
+
+
+ /**
+ An event type that indicates that a RR (Receiver Report) RTCP packet
+ has been received.
+
+ The event status is the SSRC of the sender.
+ */
+ ERtpRR = 0x30a,
+
+
+ /**
+ An event type that indicates that a BYE (Goodbye) RTCP packet
+ has been received.
+
+ The event status is the SSRC of the sender.
+ */
+ ERtpBYE = 0x30b,
+
+
+ /**
+ Not an event type, but defines the upper limit for receive stream event
+ type values.
+ */
+ ERtpSourceEventEnd = 0x3ff
+ };
+
+
+/**
+@publishedAll
+@released
+
+Indicates whether a callback function can be called once, or more than once.
+
+The appropriate enum value is passed as an argument to the
+RegisterEventCallbackL() functions of RRtpSession, RRtpSendSource,
+and RRtpReceiveSource, or to the equivalent static functions.
+
+@see RRtpSession
+@see RRtpSendSource
+@see RRtpReceiveSource
+*/
+enum TRtpOneShotness
+ {
+ /**
+ Indicates that the call back function can be called more than once.
+ */
+ ERtpNotOneShot = 0,
+
+
+ /**
+ Indicates that the call back function is only called once.
+ */
+ ERtpOneShot = 0x40000000
+ };
+
+
+
+
+/**
+@publishedAll
+*/
+typedef void (*TRtpCallbackFunction)(TAny* aPtr, const TRtpEvent& aEvent);
+
+
+
+/**
+@internalComponent
+*/
+const TInt KRtpNoParameter = KRequestPending;
+
+
+//Needed for recv-only option for RTP or RTCP
+//This must map to TRtpType
+enum TPacketType
+ {
+ EPacketRtp,
+ EPacketRtcp
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A value that can be passed as the second parameter in a call to either
+RRtpSendSource::NewSendPacketL() or RRtpSendSource::NewSendPacketLC()
+to indicate that no exension is required for the RTP send packet.
+*/
+const TInt KRtpNoExtension = -1;
+
+
+
+/**
+@publishedAll
+@released
+
+A handle to an RTP session.
+
+This is the interface to the socket-level RTP service, and provides additional
+facilities such as header parsing, re-ordering out-of-order packets,
+demultiplexing multiple sources etc.
+
+The class abstracts all RTP information going to/from a RTP socket, and its
+corresponding RTCP data.
+
+Each RTP endpoint on a device needs its own RTP session.
+
+Multiple hosts streaming to a port on this device correspond
+to different RRtpReceiveSource objects associated with the session.
+
+The class behaviour assumes that an active scheduler has already been created
+and started; the class does not function correctly if not.
+*/
+class RRtpSession
+ {
+ public:
+ /**
+ A set of bit values passed as a parameter to RRtpSession::SendRTCPPacketL()
+ to specify the SDES (Source Description) items that are to be sent with
+ the packet. One or more of these may be set.
+
+ @see RRtpSession::SendRTCPPacketL()
+ */
+ enum TRtpSendPacketType
+ {
+ /**
+ Canonical End-Point Identifier SDES Item.
+ */
+ ERtcpPacketCNAME = 1,
+
+ /**
+ User Name SDES Item.
+ */
+ ERtcpPacketNAME = 2,
+
+ /**
+ Electronic Mail Address SDES Item.
+ */
+ ERtcpPacketEMAIL = 4,
+
+ /**
+ Phone Number SDES Item.
+ */
+ ERtcpPacketPHONE = 8,
+
+ /**
+ Geographic User Location SDES Item.
+ */
+ ERtcpPacketLOC = 16,
+
+ /**
+ Application or Tool Name SDES Item
+ */
+ ERtcpPacketTOOL = 32,
+
+ /**
+ Notice/Status SDES Item
+ */
+ ERtcpPacketNOTE = 64,
+
+ /**
+ Private Extensions SDES Item
+ */
+ ERtcpPacketPRIV = 128
+ };
+
+ inline RRtpSession();
+ inline TBool IsOpen() const;
+
+ IMPORT_C void OpenL(RSocketServ& aServer, TSockAddr& aLocalAddr,
+ TSockAddr& aRemoteAddr,
+ TInt aMaxRXSize, RConnection& aConnection, TInt aPriority = EPriorityNormal,
+ const TDesC8& aCNAME = KNullDesC8);
+
+
+ IMPORT_C void OpenL(RSocketServ& aServer, TSockAddr& aLocalAddr,
+ TSockAddr& aRemoteAddr,
+ TInt aMaxRXSize, TInt aPriority = EPriorityNormal,
+ const TDesC8& aCNAME = KNullDesC8);
+
+ /**
+ @publishedPartner
+ @released
+
+ Opens the session and initialises it.
+
+ No events will be generated until after control returns to the
+ active scheduler. The client has this time to initialise the
+ object by adding event callbacks.
+
+ @param aSocket The connected socket.
+ @param aMaxRXSize The maximum size of a received packet.
+ @param aRtcpSocket The RTCP socket.
+ @param aPriority The priority to be used for internal active objects
+ @param aCNAME The CNAME. A sensible default is supplied if none is
+ provided.
+ */
+ IMPORT_C void OpenL(RSocket& aSocket, TInt aMaxRXSize,
+ RSocket& aRtcpSocket,
+ TInt aPriority = EPriorityNormal,
+ const TDesC8& aCNAME = KNullDesC8);
+
+ IMPORT_C void OpenL(RSocket& aSocket, TInt aMaxRXSize,
+ TInt aPriority = EPriorityNormal);
+
+ IMPORT_C void Close();
+
+ IMPORT_C void SetMaxRXSize(TInt aMaxRXSize);
+
+ IMPORT_C TInt MaxRXSize();
+
+
+ /**
+ @publishedPartner
+ @released
+
+ Sets the estimated bandwidth used by the session.
+
+ This is used to decide when to send RTCP status packets.
+ The default value is read from a resource file and should be a reasonably
+ sensible default based on the maximum bandwidth of the handset.
+
+ @param aBandwidth The bandwidth in bps.
+ */
+ IMPORT_C void SetBandwidth(TUint aBandwidth);
+
+
+ /**
+ @publishedPartner
+ @released
+
+ Supplies information about the profile-specific RTP
+ timestamps.
+
+ This is used to generate the RTP timestamps in RTCP packets.
+ It is not used to generate timestamps in RTP packets as they must
+ accurately relate to the time of the sample.
+
+ @param aNow The time now in RTP format
+ @param aConversion The number of nanoseconds per RTP timer tick.
+ */
+ IMPORT_C void SetRTPTimeConversion(TUint aNow, TUint aConversion);
+ IMPORT_C RRtpReceiveSource NewReceiveSourceL();
+ IMPORT_C RRtpReceiveSource NewReceiveSourceLC();
+
+ /**
+ Registers a callback for the specified event.
+
+ Some compilers may not support templated member functions. A static version
+ of this function is available that offers the same behaviour:
+ RegisterEventCallbackL(RRtpSession,TRtpEventType,void (*aCallback)(T*, const TRtpEvent&),T*,TRtpOneShotness,TInt)
+
+ @param aType The type of event.
+ @param aCallback The callback function. The function is templated, and is
+ prototyped to take a pointer to an object of the template
+ type and a const reference to a TRtpEvent. The function
+ returns void.
+ @param aPtr A pointer that is passed to the callback function when
+ that function is called.
+ @param aOneShot Indicates whether the callback function is only
+ called once, or can be called more than once.
+ @param aParameter A parameter to be passed to the registration function.
+ The meaning of this depends entirely on the event type.
+ The parameter is optional - the other overload of this
+ function is available for registrations that don't need
+ to pass a parameter.
+ */
+ template <class T> inline void
+ RegisterEventCallbackL(TRtpEventType aType,
+ void (*aCallback)(T*, const TRtpEvent&),
+ T* aPtr,
+ TRtpOneShotness aOneShot,
+ TInt aParameter)
+ {
+ PrivRegisterEventCallbackL(
+ aType|aOneShot,
+ reinterpret_cast<TRtpCallbackFunction>(aCallback),
+ static_cast<TAny*>(aPtr), aParameter);
+ }
+
+ /**
+ Registers a callback for the specified event.
+
+ Some compilers may not support templated member functions. A static version
+ of this function is available that offers the same behaviour:
+ RegisterEventCallbackL(RRtpSession,TRtpEventType,void (*aCallback)(T*, const TRtpEvent&),T*,TRtpOneShotness)
+
+ @param aType The type of event.
+ @param aCallback The callback function. The function is templated, and is
+ prototyped to take a pointer to an object of the template
+ type and a const reference to a TRtpEvent. The function
+ returns void.
+ @param aPtr A pointer that is passed to the callback function when
+ that function is called.
+ @param aOneShot Indicates whether the callback function is only
+ called once, or can be called more than once. If not
+ specified, the default is to allow the callback function
+ to be called more than once.
+ */
+ template <class T> inline void
+ RegisterEventCallbackL(TRtpEventType aType,
+ void (*aCallback)(T*, const TRtpEvent&),
+ T* aPtr,
+ TRtpOneShotness aOneShot = ERtpNotOneShot)
+ {
+ PrivRegisterEventCallbackL(
+ aType|aOneShot,
+ reinterpret_cast<TRtpCallbackFunction>(aCallback),
+ static_cast<TAny*>(aPtr));
+ }
+
+
+ /**
+ @publishedPartner
+ @released
+
+ Gets an array contining the most recent RR (Receiver Report) from
+ all hosts who are reporting on our send stream.
+
+ @return The array of RRs.
+ */
+ IMPORT_C RRtcpRRPart GetRRs();
+
+
+ /**
+ @publishedPartner
+ @released
+
+ Gets the data associated with the specified RTCP SDES (Source Description)
+ item.
+
+ Note a that the PRIV (Private Extensions) SDES item is not supported
+ by this mechanism.
+
+ @param aType The value identifying the RTCP SDES item.
+
+ @param aValue A descriptor reference to the SDES item data.
+
+ @return KErrNotFound if the item type was not found in the most recent RTCP packet
+ KErrNone if the operation is successful
+ */
+ IMPORT_C TInt GetSDES(const TInt aType, TDes8& aValue);
+
+
+ /**
+ @publishedPartner
+ @released
+
+ Sets the data associated with the specified RTCP SDES (Source Description)
+ item for sending in the next SDES packet only.
+
+ The function Leaves if duplicate values are set for the same CNAME.
+
+ Note a that the PRIV (Private Extensions) SDES item is not supported
+ by this mechanism.
+
+ NOTE - This call cannot be used to set a different CNAME for this session.
+ The default CNAME is send with every SDES packets.
+
+ @param aType The value identfying the RTCP SDES item.
+ @param aValue The SDES item data.
+
+ @return KErrTooBig if the length of the aValue is more than KMaxSdesItemLength(=255)
+ KErrNone if the operation is successful
+ */
+ IMPORT_C TInt SetSDESL(TInt aType, const TDesC8& aValue);
+
+ /**
+ @publishedPartner
+ @released
+
+ Sets the data associated with the PRIV (Private Extensions) SDES item.
+
+ @param aPrefix The value identfying the RTCP SDES item.
+ @param aValue The SDES item data.
+
+ @return KErrTooBig if the length of the aValue and aPrefix combined is more
+ than KMaxSdesItemLength(=255)
+ KErrNone if the operation is successful
+ */
+ IMPORT_C TInt SetPRIVL(const TDesC8& aPrefix, const TDesC8& aValue);
+
+
+ /**
+ @publishedPartner
+ @released
+ Sends an APP (Application Defined) RTCP Packet.
+
+ The packet is sent immediately.
+
+ If used with RTCP auto-send, the function disrupts the auto-send
+ intervals. Note however that Symbian reserves the right to fix this.
+
+ @param aApp A handle to a RTCP APP (Application Defined) packet,
+ for experimental extensions to RTCP.
+ */
+ IMPORT_C void SendAPPL(const TDesC8& aName, const TDesC8& aAppData = KNullDesC8, TUint8 aSubType = 0);
+
+
+ /**
+ @publishedPartner
+ @released
+
+ Enables or disables the automatic sending of RTCP SR (Sender Report),
+ RR (Receiver Report), and SDES (Source Description) packets.
+
+ Note that if automatic sending is not enabled and RTCP sending is required,
+ then explicit calls to SendRTCPPacketL() will be required.
+
+ @param aAutoSend ETrue, if RTCP packets need to be send automatically
+ EFalse otherwise.
+
+ @see RRtpSession::SendRTCPPacketL()
+ */
+ IMPORT_C void SetRTCPAutoSend(TBool aAutoSend);
+
+
+ /**
+ @publishedPartner
+ @released
+
+ Gets the RTCP Auto Send status.
+
+ @return True, if RTCP SR, RR and SDES packets are automatically sent,
+ false otherwise
+
+ @see RRtpSession::SetRTCPAutoSend()
+ */
+ IMPORT_C TBool RTCPAutoSend() const;
+
+ /**
+ @publishedPartner
+ @released
+
+ Sets the RTCP Auto Send interval.
+ This disables the RFC based calculation of RTCP intervals.
+ To re-enable auto calculation, set the interval to zero.
+
+ @param aInterval Time interval after which an RTCP auto-send will take place
+ */
+ IMPORT_C void SetRtcpInterval(TTimeIntervalMicroSeconds32& aInterval);
+
+ /**
+ @publishedPartner
+ @released
+ Enables Receive only option for rtp or rtcp
+
+ @param aRtpOrRtcp Takes the values from the enum TPacketType
+
+ @see RRtpSession::DontReceive()
+ */
+ IMPORT_C void DontReceive(TInt aRtpOrRtcp);
+
+ /**
+ @publishedPartner
+ @released
+ Sends an RTCP packet now.
+
+ Calling this function doesn't make much sense if auto-send is
+ on, as it will result in packets being sent at rather
+ incoherent intervals.
+
+ @param aPacketType Zero or more of the bit values defined by
+ the TRtpSendPacketType enum. The packet sent will
+ contain a SR (Sender Report) or RR (Receiver Report),
+ depending on whether any packets have actually been
+ sent, together with all SDES (Source Description) items
+ specified by this parameter.
+
+ @see TRtpSendPacketType
+ */
+ IMPORT_C void SendRTCPPacketL(TDesC8& aPacket);
+
+
+ /**
+ @publishedPartner
+ @released
+ Creates a new send stream, and returns the send stream handle.
+
+ Only one send stream per session is permitted, which means that you must not
+ call this function if the send stream has already been created.
+
+ As the send stream is an active object, it cannot handle request
+ completion events until control returns to the active scheduler.
+ Typically, clients will want to add event registrations before that.
+
+ The Code panics if the SendSource has alredy been opened.
+
+ @return The send stream handle.
+
+ This function may leave if memory is not enough.
+ */
+ IMPORT_C RRtpSendSource NewSendSourceL();
+
+
+ /**
+ @publishedPartner
+ @released
+
+ Gets the handle to the send stream object associated with this session.
+
+ The send stream object is the one created in a previous call
+ to NewSendSourceL(). If the send stream object has not been created, then
+ the returned handle will refer to a closed send stream.
+
+ @return The handle to the send stream object.
+
+ @see RRtpSendSource NewSendSourceL()
+ */
+ IMPORT_C RRtpSendSource SendSource();
+
+
+ /**
+ @publishedPartner
+ @released
+
+ Sets the number of sequential packets that must be received
+ before a stream is considered good.
+
+ Sets the maximum number of dropped packets to be considered a
+ dropout, as opposed to an ended and restarted stream.
+
+ Sets the maximum number of packets by which a packet can be delayed
+ before it is considered dropped.
+
+ @param aMaxMisorder The maximum number of packets.
+
+ @param aMaxDropout The number of sequential packets.
+
+ @param aMinSequential The number of sequential packets.
+ @post The session will be 'restarted',
+ i.e. it resets the sequence number sequence and resets all RTCP statistics.
+ */
+ IMPORT_C void SetRtpStreamParameters(TInt aMinSequential, TInt aMaxMisorder, TInt aMaxDropout);
+
+ inline TBool operator == (RRtpSession aThat) const;
+ inline TBool operator != (RRtpSession aThat) const;
+
+ /**
+ @publishedPartner
+ @released
+
+ The event manager contains a number of callback registrations, each of which
+ binds a function and pointer (normally an object) to a particular kind of
+ event. Registrations can be bound to all events on a stream.
+
+ If a function is registered for a particular event, it will be called when
+ that event occurs. One callback function can be associated with more than 1
+ callback registration. Callback functions take a pointer argument
+ which was supplied as part of the registration
+
+ @param aType Event type
+
+ @param aCallback Callback object
+
+ @param aPtr Pointer to data that needs to be passed to the callback function
+
+ @param aParameter Parameter to be passed to internal callback subsystem
+ */
+ IMPORT_C void PrivRegisterEventCallbackL(TUint aType,
+ TRtpCallbackFunction aCallback,
+ TAny* aPtr,
+ TInt aParameter);
+
+ /**
+ @publishedPartner
+ @released
+
+ The event manager contains a number of callback registrations, each of which
+ binds a function and pointer (normally an object) to a particular kind of
+ event. Registrations can be bound to all events on a stream.
+
+ If a function is registered for a particular event, it will be called when
+ that event occurs. One callback function can be associated with more than 1
+ callback registration. Callback functions take a pointer argument
+ which was supplied as part of the registration
+
+ @param aType Event type
+
+ @param aCallback Callback object
+
+ @param aPtr Pointer to data that needs to be passed to the callback function
+ */
+ IMPORT_C void PrivRegisterEventCallbackL(TUint aType,
+ TRtpCallbackFunction aCallback,
+ TAny* aPtr);
+
+ private:
+ friend class TRtpEvent;
+ CRtpSession* iPtr;
+ // Note: Comments that start with //\ are pseudo-variables used to get
+ // Doxygen collaboration diagrams to look right. Ignore them.
+ //\ RRtpSendSource sndSource_1_01;
+ //\ RRtpReceiveSource rcvSource_1_n;
+ //\ TRtpCallback callbacks_1_n;
+ //\ TRtpEvent events_1_n;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A handle to a send stream.
+
+Use this class to manage the creation and sending of packets.
+A session can have only one send stream.
+
+Only one packet can be sent at any one time.
+Once a packet has been sent, the packet cannot be closed and no further packets
+can be sent until an event signalling the completion of the send operation has
+occurred. This will be one of the events defined by the enum values:
+ERtpSendSucceeded and ERtpSendFail.
+
+A client must monitor these events so that it can schedule the sending of
+subsequent packets.
+It does this by implementing and registering callback functions that
+handle these events.
+
+@see TRtpEventType
+*/
+class RRtpSendSource
+ {
+ public:
+ inline RRtpSendSource();
+ inline TBool IsOpen() const;
+ IMPORT_C void Close();
+
+ IMPORT_C void Cancel();
+
+ template <class T> inline void
+ RegisterEventCallbackL(TRtpEventType aType,
+ void (*aCallback)(T*, const TRtpEvent&),
+ T* aPtr,
+ TRtpOneShotness aOneShot,
+ TInt aParameter)
+ {
+ PrivRegisterEventCallbackL(aType|aOneShot,
+ reinterpret_cast<TRtpCallbackFunction>(aCallback),
+ static_cast<TAny*>(aPtr), aParameter);
+ }
+
+
+ template <class T> inline void
+ RegisterEventCallbackL(TRtpEventType aType,
+ void (*aCallback)(T*, const TRtpEvent&),
+ T* aPtr,
+ TRtpOneShotness aOneShot = ERtpNotOneShot)
+ {
+ PrivRegisterEventCallbackL(aType|aOneShot,
+ reinterpret_cast<TRtpCallbackFunction>(aCallback),
+ static_cast<TAny*>(aPtr));
+ }
+
+
+
+ IMPORT_C RRtpSendPacket NewSendPacketL(TInt aPayloadSize = 0,
+ TInt aHeaderExtensionSize =
+ KRtpNoExtension);
+
+ IMPORT_C RRtpSendPacket NewSendPacketLC(TInt aPayloadSize = 0,
+ TInt aHeaderExtensionSize =
+ KRtpNoExtension);
+
+ IMPORT_C TBool IsSending();
+ IMPORT_C void SetPayloadType(TUint aPayloadType);
+ IMPORT_C void SetDefaultPayloadSize(TInt aPayloadSize);
+ /**
+ @publishedPartner
+ @released
+
+ Sends a Bye RTCP packet.
+
+ @param aReason The reason for sending the Bye RTCP packet.
+ */
+ IMPORT_C void ByeL(TDesC8& aReason);
+ IMPORT_C TUint32 GetLocalSSRC();
+
+ IMPORT_C void SetAlignment(TInt aAlignment);
+ IMPORT_C TInt Alignment() const;
+
+ inline TBool operator == (RRtpSendSource aThat) const;
+ inline TBool operator != (RRtpSendSource aThat) const;
+
+ /**
+ @publishedPartner
+ @released
+
+ The event manager contains a number of callback registrations, each of which
+ binds a function and pointer (normally an object) to a particular kind of
+ event. Registrations can be bound to all events on a stream.
+
+ If a function is registered for a particular event, it will be called when
+ that event occurs. One callback function can be associated with more than 1
+ callback registration. Callback functions take a pointer argument
+ which was supplied as part of the registration
+
+ @param aType Event type
+
+ @param aCallback Callback object
+
+ @param aPtr Pointer to data that needs to be passed to the callback function
+
+ @param aParameter Parameter to be passed to internal callback subsystem
+ */
+ IMPORT_C void PrivRegisterEventCallbackL(TUint aType,
+ TRtpCallbackFunction aCallback,
+ TAny* aPtr,
+ TInt aParameter);
+
+ /**
+ @publishedPartner
+ @released
+
+ The event manager contains a number of callback registrations, each of which
+ binds a function and pointer (normally an object) to a particular kind of
+ event. Registrations can be bound to all events on a stream.
+
+ If a function is registered for a particular event, it will be called when
+ that event occurs. One callback function can be associated with more than 1
+ callback registration. Callback functions take a pointer argument
+ which was supplied as part of the registration
+
+ @param aType Event type
+
+ @param aCallback Callback object
+
+ @param aPtr Pointer to data that needs to be passed to the callback function
+ */
+ IMPORT_C void PrivRegisterEventCallbackL(TUint aType,
+ TRtpCallbackFunction aCallback,
+ TAny* aPtr);
+ private:
+ friend class RRtpSession;
+ friend class TRtpEvent;
+ CRtpSendSource* iPtr;
+ // Note: Comments that start with //\ are pseudo-variables used to get
+ // Doxygen collaboration diagrams to look right. Ignore them.
+ //\ TRtpCallback callbacks_1_n;
+ //\ TRtpEvent events_1_n;
+ //\ TRtpSendPacket packets_1_n;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A handle to a receive stream.
+
+An object of this type represents the stream of data on a single SSRC and
+delivers the RTP packets and RTCP information in the order they
+arrive.
+
+Note that RTP does not guarantee the order of delivery, which means that the
+client may want to buffer the data.
+*/
+class RRtpReceiveSource
+ {
+ public:
+ RRtpReceiveSource();
+ inline TBool IsOpen() const;
+
+ IMPORT_C void Close();
+
+
+ template <class T> inline void
+ RegisterEventCallbackL(TRtpEventType aType,
+ void (*aCallback)(T*, const TRtpEvent&),
+ T* aPtr,
+ TRtpOneShotness aOneShot,
+ TInt aParameter)
+ {
+ PrivRegisterEventCallbackL(aType|aOneShot,
+ reinterpret_cast<TRtpCallbackFunction>(aCallback),
+ static_cast<TAny*>(aPtr), aParameter);
+ }
+
+
+ template <class T> inline void
+ RegisterEventCallbackL(TRtpEventType aType,
+ void (*aCallback)(T*, const TRtpEvent&),
+ T* aPtr,
+ TRtpOneShotness aOneShot = ERtpNotOneShot)
+ {
+ PrivRegisterEventCallbackL(aType|aOneShot,
+ reinterpret_cast<TRtpCallbackFunction>(aCallback),
+ static_cast<TAny*>(aPtr));
+ }
+
+ /**
+ @publishedPartner
+ @released
+
+ Gets the data associated with the specified RTCP SDES (Source Description)
+ item.
+
+ Note a that the PRIV (Private Extensions) SDES item is not supported
+ by this mechanism.
+
+ @param aType The value identifying the RTCP SDES item.
+
+ @return A descriptor reference to the SDES item data.
+ */
+ IMPORT_C TInt GetSDES(const TInt aType, TDes8& aValue);
+
+
+ /**
+ @publishedPartner
+ @released
+
+ Gets the most recent SR ((Sender Report) from this SSRC.
+
+ @return A handle to the SR.
+ */
+ IMPORT_C RRtcpSRPart GetSR();
+
+
+ /**
+ @publishedPartner
+ @released
+
+ Gets the reason for a BYE packet.
+
+ @return A descriptor contaning the BYE message. This is
+ KNullDesC if the source has not sent a BYE packet.
+ */
+ IMPORT_C TDesC8& GetByeReason();
+
+
+ /**
+ @publishedPartner
+ @released
+
+ Parameters from the last APP (Application Defined) packet.
+
+ @param aName Four-bytes application name
+ @param aAppData Applciation specific data
+ @param aSubType Application defined sub-type of the APP packet
+ */
+ IMPORT_C void GetLastApp(TPtrC8& aName, TPtrC8& aAppData, TUint& aSubType);
+
+ IMPORT_C RRtpReceivePacket Packet();
+
+ /**
+ @publishedPartner
+ @released
+
+ Gets the SSRC of the remote end
+
+ @return The SSRC of the remote end
+ */
+ IMPORT_C TUint SSRC() const;
+
+ inline TBool operator == (RRtpReceiveSource aThat) const;
+ inline TBool operator != (RRtpReceiveSource aThat) const;
+
+ /**
+ @publishedPartner
+ @released
+
+ The event manager contains a number of callback registrations, each of which
+ binds a function and pointer (normally an object) to a particular kind of
+ event. Registrations can be bound to all events on a stream.
+
+ If a function is registered for a particular event, it will be called when
+ that event occurs. One callback function can be associated with more than 1
+ callback registration. Callback functions take a pointer argument
+ which was supplied as part of the registration
+
+ @param aType Event type
+
+ @param aCallback Callback object
+
+ @param aPtr Pointer to data that needs to be passed to the callback function
+
+ @param aParameter Parameter to be passed to internal callback subsystem
+ */
+ IMPORT_C void PrivRegisterEventCallbackL(TUint aType,
+ TRtpCallbackFunction aCallback,
+ TAny* aPtr, TInt aParameter);
+
+ /**
+ @publishedPartner
+ @released
+
+ The event manager contains a number of callback registrations, each of which
+ binds a function and pointer (normally an object) to a particular kind of
+ event. Registrations can be bound to all events on a stream.
+
+ If a function is registered for a particular event, it will be called when
+ that event occurs. One callback function can be associated with more than 1
+ callback registration. Callback functions take a pointer argument
+ which was supplied as part of the registration
+
+ @param aType Event type
+
+ @param aCallback Callback object
+
+ @param aPtr Pointer to data that needs to be passed to the callback function
+ */
+
+ IMPORT_C void PrivRegisterEventCallbackL(TUint aType,
+ TRtpCallbackFunction aCallback,
+ TAny* aPtr);
+ private:
+ friend class RRtpSession;
+ friend class TRtpEvent;
+ CRtpReceiveSource* iPtr;
+ // Note: Comments that start with //\ are pseudo-variables used to get
+ // Doxygen collaboration diagrams to look right. Ignore them.
+ //\ TRtpCallback callbacks_1_n;
+ //\ TRtpEvent events_1_n;
+ //\ TRtpReceivePacket packets_1_n;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A handle to an RTP packet.
+
+The packet is accessed through the interface provided by this handle.
+*/
+class RRtpPacket
+ {
+ public:
+ inline RRtpPacket();
+ inline TBool IsOpen() const;
+
+ IMPORT_C void Close();
+ IMPORT_C TPtrC8 Payload() const;
+ IMPORT_C TUint SequenceNumber() const;
+ IMPORT_C TUint Timestamp() const;
+ IMPORT_C TUint SSRC() const;
+ IMPORT_C RRtpCSRCs CSRCs() const;
+ IMPORT_C TBool ExtensionPresent() const;
+ IMPORT_C RRtpHeaderExtension Extension() const;
+ IMPORT_C TBool Marker() const;
+ IMPORT_C TUint PayloadType() const;
+ IMPORT_C TUint Flags() const;
+
+ inline TBool operator == (RRtpPacket aThat) const;
+ inline TBool operator != (RRtpPacket aThat) const;
+
+ protected:
+ TRtpPacket* iPtr;
+ // Note: Comments that start with //\ are pseudo-variables used to get
+ // Doxygen collaboration diagrams to look right. Ignore them.
+ //\ RRtpHeaderExtension extension_1_01;
+ //\ RRtpCSRCs csrcs_1_01;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A handle to an RTP packet to be sent (an RTP send packet).
+
+@see RRtpSendSource
+*/
+class RRtpSendPacket : public RRtpPacket
+ {
+ public:
+ IMPORT_C void Send();
+ IMPORT_C TDes8& WritePayload();
+ IMPORT_C void SetTimestamp(TUint aTimestamp);
+ IMPORT_C void SetMarker(TBool aMark);
+ IMPORT_C void SetPayloadType(TUint aPayloadType);
+ IMPORT_C void SetFlags(TUint aFlags);
+
+ friend class RRtpSendSource;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A handle to an RTP packet received from another source.
+*/
+class RRtpReceivePacket : public RRtpPacket
+ {
+ friend class RRtpReceiveSource;
+ friend class TRtpReceivePacket;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+An RTP event.
+
+An event is generated when anything happens that a client might want
+to know about. The class encapulates two pieces of information:
+1. An event type as defined by a TRtpEventType value.
+2. Additional information whose meaning is dependent on the event type.
+
+Additional information may be implicitly associated with the event, but still
+needs to be fetched from another object, for example, when processing
+an ERtpPacketReceived event, the packet (represented by a RRtpReceivePacket
+handle) must be obtained from the receive stream (represented by a
+RRtpReceiveStream handle).
+
+Events are always associated with either an RTP session, a send stream or
+a receive stream, and this class has functions for getting the corresponding
+handle.
+
+@see RRtpSession
+@see RRtpSendSource
+@see RRtpReceiveSource
+*/
+class TRtpEvent
+ {
+ public:
+ IMPORT_C TRtpEvent(TRtpEventType aType, TInt aStatus, TAny* aData);
+ IMPORT_C RRtpSession Session() const;
+ IMPORT_C RRtpSendSource SendSource() const;
+ IMPORT_C RRtpReceiveSource ReceiveSource() const;
+ IMPORT_C TBool IsSessionEvent() const;
+ IMPORT_C TBool IsSendSourceEvent() const;
+ IMPORT_C TBool IsReceiveSourceEvent() const;
+
+ inline TRtpEventType Type() const;
+ inline TInt Status() const;
+ private:
+ TRtpEventType iType;
+ TInt iStatus;
+ TAny* iData;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Reresents an RTP packet's header extension.
+
+The format of a header extension is profile-defined.
+*/
+class RRtpHeaderExtension
+ {
+ public:
+ IMPORT_C TUint16 Type() const;
+ IMPORT_C void SetType(TUint16 aType);
+ IMPORT_C TPtrC8 Data();
+ private:
+ friend class RRtpPacket;
+ TRtpPacket* iPtr;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A handle representing the list of CSRCs in an RTP packet.
+*/
+class RRtpCSRCs
+ {
+ public:
+ IMPORT_C TInt Count() const;
+ IMPORT_C TUint operator [](TUint aIndex) const;
+ private:
+ friend class RRtpPacket;
+
+ TRtpPacket* iPtr;
+ };
+
+
+/**
+@publishedPartner
+
+A set of panic codes.
+
+in release mode, different panic codes, such as
+KERN-EXEC 3 may be generated instead.
+*/
+enum TRtpPanicCode
+ {
+ ERtpPacketIsClosed = 1,
+ ERtpPayloadTypeOutOfRange = 2,
+ ERtpSessionIsClosed = 3,
+ ERtpSourceIsClosed = 4,
+ ERtpNoExtension = 5,
+ ERtpLeaveInResponseToError = 6,
+ ERtpCantSend2PacketsAtOnce = 7,
+ ERtpWrongEventType = 8,
+ ERtpWrongParameter = 9,
+ ERtpSendSourceAlreadyOpen = 10,
+ ERtpSessionAlreadyOpen = 11,
+ //
+ ERtpCoreController = 100,
+ };
+
+GLREF_C void Panic(TRtpPanicCode aPanicCode);
+
+#include "rtp.inl"
+
+#endif // RTP_H