#13795: Initial commit for sflphone-android
includes: libexpat libyaml libdbus-c++ commoncpp ccrtp
libdbus (from android-4.0.4 sources)
TODO:
- git ignores "/jni/sflphone", sflphone repo should be cloned.
- sflphone-android only needs daemon directory. Ideally it should be possible
to clone it without cloning the whole sflphone project.
into sfl-android (commit 6a0fa7a "#13961: Fix cipher handling" has been used here)
- add pjsip-android project as a git submodule
- sflphone-android needs pjsip android project. Ideally daemon git repository
should not embed pjsip. Instead pjsip should be clone from official repositories.
Considering this, structure should have three distincts git repos:
sflphone-android/.git
sflphone-android/jni/ccrtp-1.8.0-android
sflphone-android/jni/commoncpp2-1.8.1-android
sflphone-android/jni/dbus
sflphone-android/jni/libdbus-c++-0.9.0-android
sflphone-android/jni/libexpat
sflphone-android/jni/libyaml
sflphone-android/jni/sflphone-daemon/.git
sflphone-android/jni/sflphone-daemon/src/audio
sflphone-android/jni/sflphone-daemon/src/config
sflphone-android/jni/sflphone-daemon/src/dbus
sflphone-android/jni/sflphone-daemon/src/history
sflphone-android/jni/sflphone-daemon/src/hooks
sflphone-android/jni/sflphone-daemon/src/iax
sflphone-android/jni/sflphone-daemon/src/sip
sflphone-android/jni/sflphone-daemon/src/video
sflphone-android/jni/pjsip-android/.git
Signed-off-by: Emeric Vigier <emeric.vigier@savoirfairelinux.com>
diff --git a/jni/ccrtp-1.8.0-android/src/ccrtp/rtppkt.h b/jni/ccrtp-1.8.0-android/src/ccrtp/rtppkt.h
new file mode 100644
index 0000000..8a6ae6e
--- /dev/null
+++ b/jni/ccrtp-1.8.0-android/src/ccrtp/rtppkt.h
@@ -0,0 +1,814 @@
+// Copyright (C) 2002 Federico Montesino Pouzols <fedemp@altern.org>.
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+//
+// This exception applies only to the code released under the name GNU
+// ccRTP. If you copy code from other releases into a copy of GNU
+// ccRTP, as the General Public License permits, the exception does
+// not apply to the code that you add in this way. To avoid misleading
+// anyone as to the status of such modified files, you must delete
+// this exception notice from them.
+//
+// If you write modifications of your own for GNU ccRTP, it is your choice
+// whether to permit this exception to apply to your modifications.
+// If you do not wish that, delete this exception notice.
+//
+
+#ifndef CCXX_RTP_RTPPKT_H_
+#define CCXX_RTP_RTPPKT_H_
+
+#include <ccrtp/base.h>
+#include <ccrtp/formats.h>
+#include <ccrtp/CryptoContext.h>
+
+#ifdef CCXX_NAMESPACES
+namespace ost {
+#endif
+
+/**
+ * @file rtppkt.h
+ *
+ * @short RTP packets handling.
+ **/
+
+/**
+ * @defgroup rtppacket RTP data packets manipulation.
+ * @{
+ **/
+
+/**
+ * @class RTPPacket
+ * @short A base class for both IncomingRTPPkt and OutgoingRTPPkt.
+ *
+ * Provides common low level header structures and related
+ * methods. This class provides an interface that allows for partial
+ * and generic manipulation of RTP data packets. Values are returned
+ * in host order, except raw structures, which are returned as they
+ * are sent through the network.
+ *
+ * @author David Sugar <dyfet@ostel.com>
+ **/
+
+class CryptoContext;
+
+class __EXPORT RTPPacket
+{
+private:
+ struct RTPFixedHeader;
+ struct RTPHeaderExt;
+
+public:
+ /**
+ * Constructor, construct a packet object given the memory
+ * zone its content (header and payload) is stored. Commonly
+ * used to build RTPPacket objects from incoming data.
+ *
+ * @param block whole packet
+ * @param len total length (header + payload + padding) of the
+ * packet
+ * @param duplicate whether to memcopy the packet. At present,
+ * this feature is not used.
+ * @note used in IncomingRTPPkt.
+ **/
+ RTPPacket(const unsigned char* const block, size_t len,
+ bool duplicate = false);
+
+ /**
+ * Construct a packet object without specifying its real
+ * content yet. Commonly used for outgoing packets. Header
+ * fields and payload must be filled in by another methods or
+ * by a derived constructor.
+ *
+ * @param hdrlen length of the header (including CSRC and extension).
+ * @param plen payload length.
+ * @param paddinglen pad packet to a multiple of paddinglen
+ * @note used in OutgoingRTPPkt.
+ */
+ RTPPacket(size_t hdrlen, size_t plen, uint8 paddinglen, CryptoContext* pcc= NULL);
+
+ /**
+ * Get the length of the header, including contributing
+ * sources identifiers and header extension, if present.
+ *
+ * @return number of octets.
+ **/
+ inline uint32
+ getHeaderSize() const
+ { return hdrSize; }
+
+ /**
+ * @return pointer to the payload section of the packet.
+ **/
+ inline const uint8* const
+ getPayload() const
+ { return (uint8*)(buffer + getHeaderSize()); }
+
+ /**
+ * @return length of the payload section, in octets.
+ **/
+ inline uint32
+ getPayloadSize() const
+ { return payloadSize; }
+
+ /**
+ * @return value of the PT header field.
+ **/
+ inline PayloadType
+ getPayloadType() const
+ { return static_cast<PayloadType>(getHeader()->payload); }
+
+ /**
+ * @return value of the sequence number header field, in host order.
+ **/
+ inline uint16
+ getSeqNum() const
+ { return cachedSeqNum; }
+
+ /**
+ * @return packet timestamp in host order.
+ **/
+ inline uint32
+ getTimestamp() const
+ { return cachedTimestamp; }
+
+ /**
+ * @return RTP protocol version of packet.
+ **/
+ inline uint8
+ getProtocolVersion() const
+ { return getHeader()->version; }
+
+ /**
+ * Ask whether the packet contains padding bytes at the end
+ * @return true if the header padding bit is 1.
+ **/
+ inline bool
+ isPadded() const
+ { return getHeader()->padding; }
+
+ /**
+ * Get the number of octets padding the end of the payload
+ * section.
+ *
+ * @return Padding length in octets.
+ **/
+ inline uint8
+ getPaddingSize() const
+ { return buffer[total - 1]; }
+
+ /**
+ * Ask whether the packet is marked (for isntance, is a new
+ * talk spurt in some audio profiles).
+ *
+ * @return true is the header marker bit is 1.
+ **/
+ inline bool
+ isMarked() const
+ { return getHeader()->marker; }
+
+ /**
+ * Ask whether the packet contains header extensions.
+ *
+ * @return true if the header extension bit is 1.
+ **/
+ inline bool
+ isExtended() const
+ { return getHeader()->extension; }
+
+ /**
+ * Get the number of contributing sources specified in the
+ * packet header.
+ **/
+ inline uint16
+ getCSRCsCount() const
+ { return getHeader()->cc; }
+
+ /**
+ * Get the 32-bit identifiers of the contributing sources for
+ * the packet as an array, of length getCSRCsCount().
+ *
+ * @return An array of CSRC identifiers as they are in the
+ * packet (in network order).
+ **/
+ inline const uint32*
+ getCSRCs() const
+ { return static_cast<const uint32*>(&(getHeader()->sources[1])); }
+
+ /**
+ * Get the first 16 bits (in network order) of the header of
+ * the RTP header extension. Its meaning is undefined at this
+ * level.
+ *
+ * @return 0 if the packet has no header extension, otherwise
+ * the first 16 bits of the header extension, in
+ * network order.
+ *
+ * @note 0 could be a valid value for the first 16 bits, in
+ * that case RTPPacket::isExtended() should be use.
+ **/
+ inline uint16
+ getHdrExtUndefined() const
+ { return (isExtended()? getHeaderExt()->undefined : 0); }
+
+ /**
+ * Get the length (in octets) of the data contained in the
+ * header extension. Note that this length does not include
+ * the four octets at the beginning of the header extension.
+ *
+ * @return 0 if the packet has no header extension, otherwise
+ * the length.
+ *
+ * @note 0 is a valid value for this field, so
+ * RTPPacket::isExtended() should be used.
+ **/
+ inline uint32
+ getHdrExtSize() const
+ { return (isExtended()?
+ (static_cast<uint32>(ntohs(getHeaderExt()->length)) << 2) :
+ 0); }
+
+ /**
+ * Get the content of the header extension.
+ *
+ * @return NULL if the packet has no header extension, otherwise
+ * a pointer to the packet header extension content.
+ **/
+ inline const unsigned char*
+ getHdrExtContent() const
+ { return (isExtended() ?
+ (reinterpret_cast<const unsigned char*>(getHeaderExt()) +
+ sizeof(RTPHeaderExt)) :
+ NULL); }
+
+ /**
+ * Get the raw packet as it will be sent through the network.
+ *
+ * @return memory zone where the raw packet structure is
+ * stored in.
+ **/
+ inline const unsigned char* const
+ getRawPacket() const
+ { return buffer; }
+
+ /**
+ * Get the raw packet length, including header, extension,
+ * payload and padding.
+ *
+ * @return size of the raw packet structure.
+ **/
+ inline uint32
+ getRawPacketSize() const
+ { return total; }
+
+ inline uint32
+ getRawPacketSizeSrtp() const
+ { return total + srtpLength; }
+
+ inline size_t
+ getSizeOfFixedHeader() const
+ { return sizeof(RTPFixedHeader); }
+
+ /**
+ * Re-compute payload length.
+ *
+ * This recomputation may be necessary in case of SRTP. We need to decrypt
+ * the packet before we can handle padding. See @c takeInDataPacket in
+ * @c incqueue.cpp
+ *
+ * @param padding
+ * If true then set padding flag in RTP header and re-compute
+ * payloadSize.
+ */
+ void reComputePayLength(bool padding);
+
+protected:
+ /**
+ * Destructor, free the buffer provided in the constructor.
+ **/
+ inline virtual ~RTPPacket()
+ { endPacket(); }
+
+ /**
+ * Free memory allocated for the packet.
+ **/
+ void
+ endPacket();
+
+ /**
+ * Return low level structure for the header of the packet.
+ *
+ * @return RTPFixedHeader pointer to the header of the packet.
+ **/
+ inline RTPFixedHeader*
+ getHeader() const
+ { return reinterpret_cast<RTPFixedHeader*>(buffer); }
+
+ inline void
+ setExtension(bool e)
+ { getHeader()->extension = e; }
+
+ /**
+ * Get a pointer to RTPHeaderExt pointing after the RTP header
+ * (fixed part plus contributing sources). No check for
+ * for the X bit is done.
+ *
+ * @return header extension if present, garbage if not.
+ **/
+ inline const RTPHeaderExt*
+ getHeaderExt() const
+ {
+ uint32 fixsize = sizeof(RTPFixedHeader) + (getHeader()->cc << 2);
+ return (reinterpret_cast<RTPHeaderExt*>(buffer + fixsize));
+ }
+
+ /**
+ * Obtain the absolute timestamp carried in the packet header.
+ *
+ * @return 32-bit timestamp in host order.
+ **/
+ inline uint32
+ getRawTimestamp() const
+ { return ntohl(getHeader()->timestamp); }
+
+ inline void
+ setbuffer(const void* src, size_t len, size_t pos)
+ { memcpy(buffer + pos,src,len); }
+
+ /// Packet sequence number in host order.
+ uint16 cachedSeqNum;
+ /// Packet timestamp in host order (includes initial shift).
+ uint32 cachedTimestamp;
+
+ /**
+ * Offset into packet memory pointing to area for SRTP data.
+ *
+ * This offset points to the memory where the SRTP protect will
+ * store the authentication and MKI data.
+ */
+ uint32 srtpDataOffset;
+
+ /**
+ * Lebgth of additional SRTP data.
+ *
+ * Covers the SRTP authentication and MKI data.
+ */
+ int32 srtpLength;
+
+ /// total length, including header, payload and padding
+ uint32 total;
+
+ /// note: payload (not full packet) size.
+ uint32 payloadSize;
+
+private:
+ /// packet in memory
+ unsigned char* buffer;
+ /// size of the header, including contributing sources and extensions
+ uint32 hdrSize;
+ /// whether the object was contructed with duplicated = true
+ bool duplicated;
+
+#ifdef CCXX_PACKED
+#pragma pack(1)
+#endif
+ /**
+ * @struct RTPFixedHeader
+ * @short RTP fixed header as it is send through the network.
+ *
+ * A low-level representation for generic RTP packet header as
+ * defined in RFC 1889. A packet consists of the fixed RTP
+ * header, a possibly empty list of contributing sources and
+ * the payload. Header contents are kept in network (big
+ * endian) order.
+ **/
+ struct RTPFixedHeader
+ {
+#if __BYTE_ORDER == __BIG_ENDIAN
+ /// For big endian boxes
+ unsigned char version:2; ///< Version, currently 2
+ unsigned char padding:1; ///< Padding bit
+ unsigned char extension:1; ///< Extension bit
+ unsigned char cc:4; ///< CSRC count
+ unsigned char marker:1; ///< Marker bit
+ unsigned char payload:7; ///< Payload type
+#else
+ /// For little endian boxes
+ unsigned char cc:4; ///< CSRC count
+ unsigned char extension:1; ///< Extension bit
+ unsigned char padding:1; ///< Padding bit
+ unsigned char version:2; ///< Version, currently 2
+ unsigned char payload:7; ///< Payload type
+ unsigned char marker:1; ///< Marker bit
+#endif
+ uint16 sequence; ///< sequence number
+ uint32 timestamp; ///< timestamp
+ uint32 sources[1]; ///< contributing sources
+ };
+
+ /**
+ * @struct RFC2833Payload
+ * @short a structure defining RFC2833 Telephony events.
+ *
+ * structure to define RFC2833 telephony events in RTP. You can
+ * use this by recasing the pointer returned by getPayload().
+ */
+
+public:
+ struct RFC2833Payload
+ {
+#if __BYTE_ORDER == __BIG_ENDIAN
+ uint8 event : 8;
+ bool ebit : 1;
+ bool rbit : 1;
+ uint8 vol : 6;
+ uint16 duration : 16;
+#else
+ uint8 event : 8;
+ uint8 vol : 6;
+ bool rbit : 1;
+ bool ebit : 1;
+ uint16 duration : 16;
+#endif
+ };
+
+private:
+ /**
+ * @struct RTPHeaderExt
+ *
+ * Fixed component of the variable-length header extension,
+ * appended to the fixed header, after the CSRC list, when X
+ * == 1.
+ **/
+ struct RTPHeaderExt
+ {
+ uint16 undefined; ///< to be defined
+ uint16 length; ///< number of 32-bit words in the extension
+ };
+#ifdef CCXX_PACKED
+#pragma pack()
+#endif
+
+ /* definitions for access to most common 2833 fields... */
+
+public:
+ /**
+ * Fetch a raw 2833 packet.
+ *
+ * @return low level 2833 data structure.
+ */
+ inline struct RFC2833Payload *getRaw2833Payload(void)
+ {return (struct RFC2833Payload *)getPayload();}
+
+ /**
+ * Fetch 2833 duration field.
+ *
+ * @return 2833 duration in native host machine byte order.
+ */
+ inline uint16 get2833Duration(void)
+ {return ntohs(getRaw2833Payload()->duration);}
+
+ /**
+ * Set 2833 duration field.
+ *
+ * @param timestamp to use, native host machine byte order.
+ */
+ inline void set2833Duration(uint16 timestamp)
+ {getRaw2833Payload()->duration = htons(timestamp);}
+};
+
+/**
+ * @class OutgoingRTPPkt
+ * @short RTP packets being sent.
+ *
+ * This class is intented to construct packet objects just before they
+ * are inserted into the sending queue, so that they are processed in
+ * a understandable and format independent manner inside the stack.
+ *
+ * @author Federico Montesino Pouzols <fedemp@altern.org>
+ **/
+class __EXPORT OutgoingRTPPkt : public RTPPacket
+{
+public:
+ /**
+ * Construct a new packet to be sent, containing several
+ * contributing source identifiers, header extensions and
+ * payload.
+ *
+ * A new copy in memory (holding all this components
+ * along with the fixed header) is created. If the pointer
+ * to the SRTP CryptoContext is not NULL and holds a CryptoContext
+ * for the SSRC take the SSRC data into account when computing
+ * the required memory buffer.
+ *
+ * @param csrcs array of countributing source 32-bit
+ * identifiers, in host order.
+ * @param numcsrc number of CSRC identifiers in the array.
+ * @param hdrext whole header extension.
+ * @param hdrextlen size of whole header extension, in octets.
+ * @param data payload.
+ * @param datalen payload length, in octets.
+ * @param paddinglen pad packet to a multiple of paddinglen.
+ * @param pcc Pointer to the SRTP CryptoContext, defaults to NULL
+ * if not specified.
+ *
+ * @note For efficiency purposes, since this constructor is
+ * valid for all packets but is too complex for the common
+ * case, two simpler others are provided.
+ **/
+ OutgoingRTPPkt(const uint32* const csrcs, uint16 numcsrc,
+ const unsigned char* const hdrext, uint32 hdrextlen,
+ const unsigned char* const data, size_t datalen,
+ uint8 paddinglen= 0, CryptoContext* pcc= NULL);
+
+ /**
+ * Construct a new packet to be sent, containing several
+ * contributing source identifiers and payload.
+ *
+ * A new copy in
+ * memory (holding all this components along with the fixed
+ * header) is created. If the pointer
+ * to the SRTP CryptoContext is not NULL and holds a CryptoContext
+ * for the SSRC take the SSRC data into account when computing
+ * the required memory buffer.
+ *
+ * @param csrcs array of countributing source 32-bit
+ * identifiers, in host order.
+ * @param numcsrc number of CSRC identifiers in the array.
+ * @param data payload.
+ * @param datalen payload length, in octets.
+ * @param paddinglen pad packet to a multiple of paddinglen.
+ * @param pcc Pointer to the SRTP CryptoContext, defaults to NULL
+ * if not specified.
+ **/
+ OutgoingRTPPkt(const uint32* const csrcs, uint16 numcsrc,
+ const unsigned char* const data, size_t datalen,
+ uint8 paddinglen= 0, CryptoContext* pcc= NULL);
+
+ /**
+ * Construct a new packet (fast variant, with no contributing
+ * sources and no header extension) to be sent.
+ *
+ * A new copy in
+ * memory (holding the whole packet) is created. If the pointer
+ * to the SRTP CryptoContext is not NULL and holds a CryptoContext
+ * for the SSRC take the SSRC data into account when computing
+ * the required memory buffer.
+ *
+ * @param data payload.
+ * @param datalen payload length, in octets.
+ * @param paddinglen pad packet to a multiple of paddinglen.
+ * @param pcc Pointer to the SRTP CryptoContext, defaults to NULL
+ * if not specified.
+ **/
+ OutgoingRTPPkt(const unsigned char* const data, size_t datalen,
+ uint8 paddinglen= 0, CryptoContext* pcc= NULL);
+
+ ~OutgoingRTPPkt()
+ { }
+
+ /**
+ * @param pt Packet payload type.
+ **/
+ inline void
+ setPayloadType(PayloadType pt)
+ { getHeader()->payload = pt; }
+
+ /**
+ * Sets the sequence number in the header.
+ *
+ * @param seq Packet sequence number, in host order.
+ **/
+ inline void
+ setSeqNum(uint16 seq)
+ {
+ cachedSeqNum = seq;
+ getHeader()->sequence = htons(seq);
+ }
+
+ /**
+ * @param pts Packet timestamp, in host order.
+ **/
+ inline void
+ setTimestamp(uint32 pts)
+ {
+ cachedTimestamp = pts;
+ getHeader()->timestamp = htonl(pts);
+ }
+
+ /**
+ * Set synchronization source numeric identifier.
+ *
+ * @param ssrc 32-bit Synchronization SouRCe numeric
+ * identifier, in host order.
+ **/
+ inline void
+ setSSRC(uint32 ssrc) const
+ { getHeader()->sources[0] = htonl(ssrc); }
+
+ /**
+ * Set synchronization source numeric identifier. Special
+ * version to save endianness conversion.
+ *
+ * @param ssrc 32-bit Synchronization SouRCe numeric
+ * identifier, in network order.
+ **/
+ inline void
+ setSSRCNetwork(uint32 ssrc) const
+ { getHeader()->sources[0] = ssrc; }
+
+ /**
+ * Specify the value of the marker bit. By default, the marker
+ * bit of outgoing packets is false/0. This method allows to
+ * explicity specify and change that value.
+ *
+ * @param mark value for the market bit.
+ */
+ inline void
+ setMarker(bool mark)
+ { getHeader()->marker = mark; }
+
+ /**
+ * Called packet is setup.
+ *
+ * This private method computes the SRTP data and stores it in the
+ * packet. Then encrypt the payload data (ex padding).
+ */
+ void protect(uint32 ssrc, CryptoContext* pcc);
+
+ /**
+ * Outgoing packets are equal if their sequence numbers match.
+ **/
+ inline bool
+ operator==(const OutgoingRTPPkt &p) const
+ { return ( this->getSeqNum() == p.getSeqNum() ); }
+
+ /**
+ * Outgoing packets are not equal if their sequence numbers differ.
+ **/
+ inline bool
+ operator!=(const OutgoingRTPPkt &p) const
+ { return ( this->getSeqNum() != p.getSeqNum() ); }
+
+private:
+ /**
+ * Copy constructor from objects of its same kind, declared
+ * private to avoid its use.
+ **/
+ OutgoingRTPPkt(const OutgoingRTPPkt &o);
+
+ /**
+ * Assignment operator from objects of its same kind, declared
+ * private to avoid its use.
+ **/
+ OutgoingRTPPkt&
+ operator=(const OutgoingRTPPkt &o);
+
+ /**
+ * Set the list of CSRC identifiers in an RTP packet,
+ * switching host to network order.
+ */
+ void setCSRCArray(const uint32* const csrcs, uint16 numcsrc);
+
+};
+
+/**
+ * @class IncomingRTPPkt
+ *
+ * @short RTP packets received from other participants.
+ *
+ * This class is intented to construct a packet object just after
+ * every packet is received by the scheduled queue, so that they are
+ * processed in an understandable and format independent manner inside
+ * the stack.
+ *
+ * @author Federico Montesino Pouzols <fedemp@altern.org>
+ */
+class __EXPORT IncomingRTPPkt : public RTPPacket
+{
+public:
+ /**
+ * Build an RTP packet object from a data buffer. This
+ * constructor first performs a generic RTP data packet header
+ * check, whose result can be checked via isHeaderValid().
+ *
+ * @param block pointer to the buffer the whole packet is stored in.
+ * @param len length of the whole packet, expressed in octets.
+ *
+ * @note If check fails, the packet object is
+ * incomplete. checking isHeaderValid() is recommended before
+ * using a new RTPPacket object.
+ **/
+ IncomingRTPPkt(const unsigned char* block, size_t len);
+
+ ~IncomingRTPPkt()
+ { }
+
+ /**
+ * Get validity of this packet
+ * @return whether the header check performed at construction
+ * time ended successfully.
+ **/
+ inline bool
+ isHeaderValid()
+ { return headerValid; }
+
+ /**
+ * Get synchronization source numeric identifier.
+ *
+ * @return 32-bits Synchronization SouRCe numeric identifier,
+ * in host order.
+ **/
+ inline uint32
+ getSSRC() const
+ { return cachedSSRC; }
+
+ /**
+ * Unprotect a received packet.
+ *
+ * Perform SRTP processing on this packet.
+ *
+ * @param pcc Pointer to SRTP CryptoContext.
+ * @return
+ * one if no errors, -1 if authentication failed, -2 if
+ * replay check failed
+ */
+ int32
+ unprotect(CryptoContext* pcc);
+
+ /**
+ * Two incoming packets are equal if they come from sources
+ * with the same SSRC and have the same sequence number.
+ **/
+ inline bool
+ operator==(const IncomingRTPPkt &p) const
+ { return ( (this->getSeqNum() == p.getSeqNum()) &&
+ (this->getSSRC() == p.getSSRC()) ); }
+
+ /**
+ * Two incoming packets are not equal if they come from
+ * different sources or have different sequence numbers.
+ **/
+ inline bool
+ operator!=(const IncomingRTPPkt &p) const
+ { return !( *this == p ); }
+
+private:
+ /**
+ * Copy constructor from objects of its same kind, declared
+ * private to avoid its use.
+ **/
+ IncomingRTPPkt(const IncomingRTPPkt &ip);
+
+ /**
+ * Assignment operator from objects of its same kind, declared
+ * private to avoid its use.
+ */
+ IncomingRTPPkt&
+ operator=(const IncomingRTPPkt &ip);
+
+ /// Header validity, checked at construction time.
+ bool headerValid;
+ /// SSRC 32-bit identifier in host order.
+ uint32 cachedSSRC;
+ // Masks for RTP header validation: types matching RTCP SR or
+ // RR must be rejected to avoid accepting misaddressed RTCP
+ // packets.
+ static const uint16 RTP_INVALID_PT_MASK;
+ static const uint16 RTP_INVALID_PT_VALUE;
+};
+
+/** @}*/ // rtppacket
+
+#ifdef CCXX_NAMESPACES
+}
+#endif
+
+#endif // ndef CCXX_RTP_RTPPKT_H_
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-basic-offset: 8
+ * End:
+ */