jrtplib.tex

jrtplib3.3.0 最新下载的jrtplib. 我现在正在用jrtplib2.7版本

					\end{itemize}

				\Paragraph{\tt RTCPSRPacket}\headerfile{rtcpsrpacket.h}\inherits{RTCPPacket}
					
					This class describes an RTCP sender report packet. The interface
					is the following:
					\begin{itemize}
						\item {\tt RTCPSRPacket(u\_int8\_t *data, size\_t datalen)}\\
							Creates an instance based on the data in {\tt data} with
							length {\tt datalen}. Since the {\tt data} pointer
							is referenced inside the class (no copy of the data is
							made) one must make sure that the memory it points to is
							valid as long as the class instance exists.
						\item {\tt u\_int32\_t GetSenderSSRC() const}\\
							Returns the SSRC of the participant who sent this packet.
						\item {\tt RTPNTPTime GetNTPTimestamp() const}\\
							Returns the NTP timestamp contained in the sender report.
						\item {\tt u\_int32\_t GetRTPTimestamp() const}\\
							Returns the RTP timestamp contained in the sender report.
						\item {\tt u\_int32\_t GetSenderPacketCount() const}\\
							Returns the sender's packet count contained in the
							sender report.
						\item {\tt u\_int32\_t GetSenderOctetCount() const}\\
							Returns the sender's octet count contained in the sender
							report.
						\item {\tt int GetReceptionReportCount() const}\\
							Returns the number of reception report blocks present
							in this packet.
						\item {\tt u\_int32\_t GetSSRC(int index) const}\\
							Returns the SSRC of the reception report block described
							by {\tt index} which may have a value from $0$ to
							{\tt GetReceptionReportCount()}-$1$. Note that no
							check is performed to see if {\tt index} is valid.
						\item {\tt u\_int8\_t GetFractionLost(int index) const}\\
							Returns the `fraction lost' field of the reception 
							report described by {\tt index} which may have a value 
							from $0$ to {\tt GetReceptionReportCount()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
						\item {\tt int32\_t GetLostPacketCount(int index) const}\\
							Returns the number of lost packets in the reception 
							report block described by {\tt index} which may have a value 
							from $0$ to {\tt GetReceptionReportCount()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
						\item {\tt u\_int32\_t GetExtendedHighestSequenceNumber(int index) const}\\
							Returns the extended highest sequence number of the reception 
							report block described by {\tt index} which may have a value 
							from $0$ to {\tt GetReception\-Report\-Count()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
						\item {\tt u\_int32\_t GetJitter(int index) const}\\
							Returns the jitter field of the reception 
							report block described by {\tt index} which may have a value 
							from $0$ to {\tt GetReceptionReportCount()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
						\item {\tt u\_int32\_t GetLSR(int index) const}\\
							Returns the LSR field of the reception 
							report block described by {\tt index} which may have a value 
							from $0$ to {\tt GetReceptionReportCount()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
						\item {\tt u\_int32\_t GetDLSR(int index) const}\\
							Returns the DLSR field of the reception 
							report block described by {\tt index} which may have a value 
							from $0$ to {\tt GetReceptionReportCount()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
					\end{itemize}

				\Paragraph{\tt RTCPRRPacket}\headerfile{rtcprrpacket.h}\inherits{RTCPPacket}

					This class describes an RTCP receiver report packet. The interface
					is the following:
					\begin{itemize}
						\item {\tt RTCPRRPacket(u\_int8\_t *data, size\_t datalen)}\\
							Creates an instance based on the data in {\tt data} with
							length {\tt datalen}. Since the {\tt data} pointer
							is referenced inside the class (no copy of the data is
							made) one must make sure that the memory it points to is
							valid as long as the class instance exists.
						\item {\tt u\_int32\_t GetSenderSSRC() const}\\
							Returns the SSRC of the participant who sent this packet.
						\item {\tt int GetReceptionReportCount() const}\\
							Returns the number of reception report blocks present
							in this packet.
						\item {\tt u\_int32\_t GetSSRC(int index) const}\\
							Returns the SSRC of the reception report block described
							by {\tt index} which may have a value from $0$ to
							{\tt GetReceptionReportCount()}-$1$. Note that no
							check is performed to see if {\tt index} is valid.
						\item {\tt u\_int8\_t GetFractionLost(int index) const}\\
							Returns the `fraction lost' field of the reception 
							report described by {\tt index} which may have a value 
							from $0$ to {\tt GetReceptionReportCount()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
						\item {\tt int32\_t GetLostPacketCount(int index) const}\\
							Returns the number of lost packets in the reception 
							report block described by {\tt index} which may have a value 
							from $0$ to {\tt GetReceptionReportCount()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
						\item {\tt u\_int32\_t GetExtendedHighestSequenceNumber(int index) const}\\
							Returns the extended highest sequence number of the reception 
							report block described by {\tt index} which may have a value 
							from $0$ to {\tt GetReception\-Report\-Count()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
						\item {\tt u\_int32\_t GetJitter(int index) const}\\
							Returns the jitter field of the reception 
							report block described by {\tt index} which may have a value 
							from $0$ to {\tt GetReceptionReportCount()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
						\item {\tt u\_int32\_t GetLSR(int index) const}\\
							Returns the LSR field of the reception 
							report block described by {\tt index} which may have a value 
							from $0$ to {\tt GetReceptionReportCount()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
						\item {\tt u\_int32\_t GetDLSR(int index) const}\\
							Returns the DLSR field of the reception 
							report block described by {\tt index} which may have a value 
							from $0$ to {\tt GetReceptionReportCount()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
					\end{itemize}
		
				\Paragraph{\tt RTCPSDESPacket}\headerfile{rtcpsdespacket.h}\inherits{RTCPPacket}

					This class describes an RTCP SDES packet. In the {\tt RTCP\-SDES\-Packet}
					class, the following type is defined:
					\begin{verbatim}
						enum ItemType { None, CNAME, NAME, EMAIL, PHONE,
						                LOC, TOOL, NOTE, PRIV, Unknown };
					\end{verbatim}
					This type is used to identify the type of an SDES item. The type
					{\tt None} is used when the iteration over the items has finished;
					{\tt Unknown} is used when there really is an item present, but
					the type is not a standard type.

					The class interface is the following:
					\begin{itemize}
						\item {\tt RTCPSDESPacket(u\_int8\_t *data, size\_t datalen)}\\
							Creates an instance based on the data in {\tt data} with
							length {\tt datalen}. Since the {\tt data} pointer
							is referenced inside the class (no copy of the data is
							made) one must make sure that the memory it points to is
							valid as long as the class instance exists.
						\item {\tt int GetChunkCount() const}\\
							Returns the number of SDES chunks in the SDES packet.
							Each chunk has its own SSRC identifier.
						\item {\tt bool GotoFirstChunk()}\\
							Starts the iteration. If no SDES chunks are present,
							the function returns {\tt false}. Otherwise, it
							returns {\tt true} and sets the current chunk to be
							the first chunk.
						\item {\tt bool GotoNextChunk()}\\
							Sets the current chunk to the next available chunk.
							If no next chunk is present, this function returns
							{\tt false}, otherwise it returns {\tt true}.
						\item {\tt u\_int32\_t GetChunkSSRC() const}\\
							Returns the SSRC identifier of the current chunk.
						\item {\tt bool GotoFirstItem()}\\
							Starts the iteration over the SDES items in the current
							chunk. If no SDES items are present, the function returns
							{\tt false}. Otherwise, the function sets the current item
							to be the first one and returns {\tt true}.
						\item {\tt bool GotoNextItem()}\\
							If there's another item in the chunk, the current item
							is set to be the next one and the function returns {\tt true}.
							Otherwise, the function returns {\tt false}.
						\item {\tt ItemType GetItemType() const}\\
							Returns the SDES item type of the current item in the current
							chunk.
						\item {\tt size\_t GetItemLength() const}\\
							Returns the item length of the current item in the current
							chunk.
						\item {\tt u\_int8\_t *GetItemData()}\\
							Returns the item data of the current item in the current
							chunk.
					\end{itemize}

					If SDES private item support was enabled at compile-time, the following
					members can be used if the current item is an SDES private item.
					\begin{itemize}
						\item {\tt size\_t GetPRIVPrefixLength()}\\
							Returns the length of the prefix string of the private
							item.
						\item {\tt u\_int8\_t *GetPRIVPrefixData()}\\
							Returns the actual data of the prefix string.
						\item {\tt size\_t GetPRIVValueLength()}\\
							Returns the length of the value string of the private
							item.
						\item {\tt u\_int8\_t *GetPRIVValueData()}\\
							Returns the actual value data of the private item.
					\end{itemize}

				\Paragraph{\tt RTCPAPPPacket}\headerfile{rtcpapppacket.h}\inherits{RTCPPacket}
					
					The class {\tt RTCPAPPPacket} describes an RTCP APP packet.
					The following member functions are available:
					\begin{itemize}
						\item {\tt RTCPAPPPacket(u\_int8\_t *data, size\_t datalen)}\\
							Creates an instance based on the data in {\tt data} with
							length {\tt datalen}. Since the {\tt data} pointer
							is referenced inside the class (no copy of the data is
							made) one must make sure that the memory it points to is
							valid as long as the class instance exists.
						\item {\tt u\_int8\_t GetSubType() const}\\
							Returns the subtype contained in the APP packet.
						\item {\tt u\_int32\_t GetSSRC() const}\\
							Returns the SSRC of the source which sent this packet.
						\item {\tt u\_int8\_t *GetName()}\\
							Returns the name contained in the APP packet. This always
							consists of four bytes and is not NULL-terminated.
						\item {\tt u\_int8\_t *GetAPPData()}\\
							Returns a pointer to the actual data.
						\item {\tt size\_t GetAPPDataLength() const}\\
							Returns the length of the actual data.
					\end{itemize}
				
				\Paragraph{\tt RTCPBYEPacket}\headerfile{rtcpbyepacket.h}\inherits{RTCPPacket}

					An RTCP BYE packet is represented by the class {\tt RTCPBYEPacket}
					which has the following member functions:
					\begin{itemize}
						\item {\tt RTCPBYEPacket(u\_int8\_t *data, size\_t datalen)}\\
							Creates an instance based on the data in {\tt data} with
							length {\tt datalen}. Since the {\tt data} pointer
							is referenced inside the class (no copy of the data is
							made) one must make sure that the memory it points to is
							valid as long as the class instance exists.
						\item {\tt int GetSSRCCount() const}\\
							Returns the number of SSRC identifiers present in this
							BYE packet.
						\item {\tt u\_int32\_t GetSSRC(int index) const}\\
							Returns the SSRC described by {\tt index} which may have a value 
							from $0$ to {\tt GetSSRCCount()}-$1$. Note that 
							no check is performed to see if {\tt index} is valid.
						\item {\tt bool HasReasonForLeaving() const}\\
							Returns true if the BYE packet contains a reason for
							leaving.
						\item {\tt size\_t GetReasonLength() const}\\
							Returns the length of the string which describes why
							the source(s) left.
						\item {\tt u\_int8\_t *GetReasonData()}\\
							Returns the actual reason data.
					\end{itemize}
	
				\Paragraph{\tt RTCPUnknownPacket}\headerfile{rtcpunknownpacket.h}\inherits{RTCPPacket}
				
					This class doesn't have any extra member functions besides
					the ones it inherited. Note that since an unknown packet type
					doesn't have any format to check against, the {\tt IsKnownFormat}
					function will trivially return {\tt true}. Only the following
					constructor is available:
					\begin{itemize}
						\item {\tt RTCPUnknownPacket(u\_int8\_t *data, size\_t datalen)}\\
							Creates an instance based on the data in {\tt data} with
							length {\tt datalen}. Since the {\tt data} pointer
							is referenced inside the class (no copy of the data is
							made) one must make sure that the memory it points to is
							valid as long as the class instance exists.
					\end{itemize}
					
			\subsubsection{\tt RTCPCompoundPacketBuilder}\headerfile{rtpcompoundpacket\-builder.h}\inherits{RTCPCompoundPacket}
				
				The {\tt RTCPCompoundPacketBuilder} class can be used to
				construct an RTCP compound packet. It inherits the member
				functions of {\tt RTCP\-Compound\-Packet} which can be used
				to access the information in the compound packet once it has
				been built successfully. The member functions described below
				return {\tt ERR\_\-RTP\_\-RTCPCOMP\-PACK\-BUILDER\_\-NOT\-ENOUGH\-BYTES\-LEFT}
				if the action would cause the maximum allowed size to be
				exceeded.
				\begin{itemize}
					\item {\tt int InitBuild(size\_t maxpacketsize)}\\
						Starts building an RTCP compound packet with maximum size {\tt maxpacketsize}.
						New memory will be allocated to store th