1 rtp.inl

     1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // 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

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Default constructor

    15 // 

    16 //

    17 

    18 

    19 

    20 inline RRtpSession::RRtpSession()

    21 		: iPtr(NULL)

    22 	{

    23 	}

    24 

    25 

    26 

    27 

    28 /**

    29 Tests whether the RTP session represented by this handle is open.

    30 

    31 @return ETrue, if the session is open, false otherwise. 

    32 */

    33 inline TBool RRtpSession::IsOpen() const

    34 	{

    35 	return (iPtr != NULL);

    36 	}

    37 

    38 

    39 

    40 

    41 /**

    42 Tests whether this session handle represents the same session as

    43 the one represented by the specified handle.

    44 

    45 @param aThat The handle of the session to be compared.

    46 

    47 @return ETrue, if the represented sessions are the same, false otherwise.

    48 */

    49 inline TBool RRtpSession::operator == (RRtpSession aThat) const 

    50 	{ 

    51 	return aThat.iPtr == iPtr;

    52 	}

    53 

    54 

    55 

    56 

    57 /**

    58 Tests whether this session handle represents a different session to the one

    59 represented by the specified handle.

    60 

    61 @param aThat The handle of the session to be compared.

    62 

    63 @return ETrue, if the represented sessions are different, false otherwise.

    64 */

    65 inline TBool RRtpSession::operator != (RRtpSession aThat) const 

    66 	{

    67 	return !(aThat == *this);

    68 	}

    69 

    70 

    71 

    72 

    73 /**

    74 Default constructor

    75 */

    76 inline RRtpSendSource::RRtpSendSource()

    77 		: iPtr(NULL)

    78 	{

    79 	}

    80 

    81 

    82 

    83 /**

    84 Tests whether the send stream represented by this handle is open.

    85 

    86 @return ETrue, if the send stream is open, false otherwise. 

    87 */

    88 inline TBool RRtpSendSource::IsOpen() const

    89 	{

    90 	return (iPtr != NULL);

    91 	}

    92 

    93 

    94 

    95 

    96 /**

    97 Tests whether this send stream handle represents the same send stream as

    98 the one represented by the specified handle.

    99 

   100 @param aThat The handle of the send stream to be compared.

   101 

   102 @return ETrue, if the represented send streams are the same, false otherwise.

   103 */

   104 inline TBool RRtpSendSource::operator == (RRtpSendSource aThat) const 

   105 	{ 

   106 	return aThat.iPtr == iPtr;

   107 	}

   108 

   109 

   110 

   111 

   112 /**

   113 Tests whether this send stream handle represents a different send stream to the one

   114 represented by the specified handle.

   115 

   116 @param aThat The handle of the send stream to be compared.

   117 

   118 @return ETrue, if the represented send streams are different, false otherwise.

   119 */

   120 inline TBool RRtpSendSource::operator != (RRtpSendSource aThat) const 

   121 	{

   122 	return !(aThat == *this);

   123 	}

   124 

   125 

   126 /**

   127 Default constructor

   128 */

   129 inline RRtpReceiveSource::RRtpReceiveSource()

   130 		: iPtr(NULL)

   131 	{

   132 	}

   133 

   134 

   135 

   136 

   137 /**

   138 Tests whether the receive stream represented by this handle is open.

   139 

   140 @return ETrue, if the receive stream is open, false otherwise. 

   141 */

   142 inline TBool RRtpReceiveSource::IsOpen() const

   143 	{

   144 	return (iPtr != NULL);

   145 	}

   146 

   147 

   148 

   149 

   150 /**

   151 Tests whether this receive stream handle represents the same receive stream as

   152 the one represented by the specified handle.

   153 

   154 @param aThat The handle of the receive stream to be compared.

   155 

   156 @return ETrue, if the represented receive streams are the same, false otherwise.

   157 */

   158 inline TBool RRtpReceiveSource::operator == (RRtpReceiveSource aThat) const 

   159 	{ 

   160 	return aThat.iPtr == iPtr;

   161 	}

   162 

   163 

   164 

   165 

   166 /**

   167 Tests whether this receive stream handle represents a different receive stream to the one

   168 represented by the specified handle.

   169 

   170 @param aThat The handle of the receive stream to be compared.

   171 

   172 @return ETrue, if the represented receive streams are different, false otherwise.

   173 */

   174 inline TBool RRtpReceiveSource::operator != (RRtpReceiveSource aThat) const 

   175 	{

   176 	return !(aThat == *this);

   177 	}

   178 

   179 

   180 /**

   181 Default constructor.

   182 */

   183 inline RRtpPacket::RRtpPacket()

   184 		: iPtr(NULL)

   185 	{

   186 	}

   187 

   188 

   189 

   190 

   191 /**

   192 Tests whether this packet object is open.

   193 

   194 @return ETrue, if the packet is open, false otherwise.

   195 */

   196 inline TBool RRtpPacket::IsOpen() const

   197 	{

   198 	return (iPtr != NULL);

   199 	}

   200 

   201 

   202 

   203 

   204 /**

   205 Tests whether this packet handle represents the same packet as

   206 the one represented by the specified handle.

   207 

   208 @param aThat The handle of the packet to be compared.

   209 

   210 @return ETrue, if the represented packets are the same, false otherwise.

   211 */

   212 inline TBool RRtpPacket::operator == (RRtpPacket aThat) const 

   213 	{ 

   214 	return aThat.iPtr == iPtr;

   215 	}

   216 

   217 

   218 

   219 

   220 /**

   221 Tests whether this packet handle represents a different packet to the one

   222 represented by the specified handle.

   223 

   224 @param aThat The handle of the packet to be compared.

   225 

   226 @return ETrue, if the represented packets are different, false otherwise.

   227 */

   228 inline TBool RRtpPacket::operator != (RRtpPacket aThat) const 

   229 	{

   230 	return !(aThat == *this);

   231 	}

   232 

   233 /**

   234 Gets the type of this event.

   235     

   236 @return The event type.

   237 */

   238 inline TRtpEventType TRtpEvent::Type() const 

   239 	{ 

   240 	return iType;

   241 	}

   242 	

   243 /**	

   244 Gets the event status.

   245 	

   246 The meaning of this depends on the event type.

   247 	

   248 @see TRtpEventType

   249 */

   250 inline TInt TRtpEvent::Status() const 

   251 	{ 

   252 	return iStatus;

   253 	}