Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038 #ifndef CCXX_RTP_RTPPKT_H_
00039 #define CCXX_RTP_RTPPKT_H_
00040
00041 #include <ccrtp/base.h>
00042 #include <ccrtp/formats.h>
00043 #include <ccrtp/CryptoContext.h>
00044
00045 #ifdef CCXX_NAMESPACES
00046 namespace ost {
00047 #endif
00048
00073 class CryptoContext;
00074
00075 class __EXPORT RTPPacket
00076 {
00077 private:
00078 struct RTPFixedHeader;
00079 struct RTPHeaderExt;
00080
00081 public:
00094 RTPPacket(const unsigned char* const block, size_t len,
00095 bool duplicate = false);
00096
00108 RTPPacket(size_t hdrlen, size_t plen, uint8 paddinglen, CryptoContext* pcc= NULL);
00109
00116 inline uint32
00117 getHeaderSize() const
00118 { return hdrSize; }
00119
00123 inline const uint8* const
00124 getPayload() const
00125 { return (uint8*)(buffer + getHeaderSize()); }
00126
00130 inline uint32
00131 getPayloadSize() const
00132 { return payloadSize; }
00133
00137 inline PayloadType
00138 getPayloadType() const
00139 { return static_cast<PayloadType>(getHeader()->payload); }
00140
00144 inline uint16
00145 getSeqNum() const
00146 { return cachedSeqNum; }
00147
00151 inline uint32
00152 getTimestamp() const
00153 { return cachedTimestamp; }
00154
00158 inline uint8
00159 getProtocolVersion() const
00160 { return getHeader()->version; }
00161
00166 inline bool
00167 isPadded() const
00168 { return getHeader()->padding; }
00169
00176 inline uint8
00177 getPaddingSize() const
00178 { return buffer[total - 1]; }
00179
00186 inline bool
00187 isMarked() const
00188 { return getHeader()->marker; }
00189
00195 inline bool
00196 isExtended() const
00197 { return getHeader()->extension; }
00198
00203 inline uint16
00204 getCSRCsCount() const
00205 { return getHeader()->cc; }
00206
00214 inline const uint32*
00215 getCSRCs() const
00216 { return static_cast<const uint32*>(&(getHeader()->sources[1])); }
00217
00230 inline uint16
00231 getHdrExtUndefined() const
00232 { return (isExtended()? getHeaderExt()->undefined : 0); }
00233
00245 inline uint32
00246 getHdrExtSize() const
00247 { return (isExtended()?
00248 (static_cast<uint32>(ntohs(getHeaderExt()->length)) << 2) :
00249 0); }
00250
00257 inline const unsigned char*
00258 getHdrExtContent() const
00259 { return (isExtended() ?
00260 (reinterpret_cast<const unsigned char*>(getHeaderExt()) +
00261 sizeof(RTPHeaderExt)) :
00262 NULL); }
00263
00270 inline const unsigned char* const
00271 getRawPacket() const
00272 { return buffer; }
00273
00280 inline uint32
00281 getRawPacketSize() const
00282 { return total; }
00283
00284 inline uint32
00285 getRawPacketSizeSrtp() const
00286 { return total + srtpLength; }
00287
00288 inline size_t
00289 getSizeOfFixedHeader() const
00290 { return sizeof(RTPFixedHeader); }
00291
00303 void reComputePayLength(bool padding);
00304
00305 protected:
00309 inline virtual ~RTPPacket()
00310 { endPacket(); }
00311
00315 void
00316 endPacket();
00317
00323 inline RTPFixedHeader*
00324 getHeader() const
00325 { return reinterpret_cast<RTPFixedHeader*>(buffer); }
00326
00327 inline void
00328 setExtension(bool e)
00329 { getHeader()->extension = e; }
00330
00338 inline const RTPHeaderExt*
00339 getHeaderExt() const
00340 {
00341 uint32 fixsize = sizeof(RTPFixedHeader) + (getHeader()->cc << 2);
00342 return (reinterpret_cast<RTPHeaderExt*>(buffer + fixsize));
00343 }
00344
00350 inline uint32
00351 getRawTimestamp() const
00352 { return ntohl(getHeader()->timestamp); }
00353
00354 inline void
00355 setbuffer(const void* src, size_t len, size_t pos)
00356 { memcpy(buffer + pos,src,len); }
00357
00359 uint16 cachedSeqNum;
00361 uint32 cachedTimestamp;
00362
00369 uint32 srtpDataOffset;
00370
00376 int32 srtpLength;
00377
00379 uint32 total;
00380
00382 uint32 payloadSize;
00383
00384 private:
00386 unsigned char* buffer;
00388 uint32 hdrSize;
00390 bool duplicated;
00391
00392 #ifdef CCXX_PACKED
00393 #pragma pack(1)
00394 #endif
00395
00405 struct RTPFixedHeader
00406 {
00407 #if __BYTE_ORDER == __BIG_ENDIAN
00408
00409 unsigned char version:2;
00410 unsigned char padding:1;
00411 unsigned char extension:1;
00412 unsigned char cc:4;
00413 unsigned char marker:1;
00414 unsigned char payload:7;
00415 #else
00416
00417 unsigned char cc:4;
00418 unsigned char extension:1;
00419 unsigned char padding:1;
00420 unsigned char version:2;
00421 unsigned char payload:7;
00422 unsigned char marker:1;
00423 #endif
00424 uint16 sequence;
00425 uint32 timestamp;
00426 uint32 sources[1];
00427 };
00428
00437 public:
00438 struct RFC2833Payload
00439 {
00440 #if __BYTE_ORDER == __BIG_ENDIAN
00441 uint8 event : 8;
00442 bool ebit : 1;
00443 bool rbit : 1;
00444 uint8 vol : 6;
00445 uint16 duration : 16;
00446 #else
00447 uint8 event : 8;
00448 uint8 vol : 6;
00449 bool rbit : 1;
00450 bool ebit : 1;
00451 uint16 duration : 16;
00452 #endif
00453 };
00454
00455 private:
00463 struct RTPHeaderExt
00464 {
00465 uint16 undefined;
00466 uint16 length;
00467 };
00468 #ifdef CCXX_PACKED
00469 #pragma pack()
00470 #endif
00471
00472
00473
00474 public:
00480 inline struct RFC2833Payload *getRaw2833Payload(void)
00481 {return (struct RFC2833Payload *)getPayload();}
00482
00488 inline uint16 get2833Duration(void)
00489 {return ntohs(getRaw2833Payload()->duration);}
00490
00496 inline void set2833Duration(uint16 timestamp)
00497 {getRaw2833Payload()->duration = htons(timestamp);}
00498 };
00499
00510 class __EXPORT OutgoingRTPPkt : public RTPPacket
00511 {
00512 public:
00539 OutgoingRTPPkt(const uint32* const csrcs, uint16 numcsrc,
00540 const unsigned char* const hdrext, uint32 hdrextlen,
00541 const unsigned char* const data, size_t datalen,
00542 uint8 paddinglen= 0, CryptoContext* pcc= NULL);
00543
00564 OutgoingRTPPkt(const uint32* const csrcs, uint16 numcsrc,
00565 const unsigned char* const data, size_t datalen,
00566 uint8 paddinglen= 0, CryptoContext* pcc= NULL);
00567
00584 OutgoingRTPPkt(const unsigned char* const data, size_t datalen,
00585 uint8 paddinglen= 0, CryptoContext* pcc= NULL);
00586
00587 ~OutgoingRTPPkt()
00588 { }
00589
00593 inline void
00594 setPayloadType(PayloadType pt)
00595 { getHeader()->payload = pt; }
00596
00602 inline void
00603 setSeqNum(uint16 seq)
00604 {
00605 cachedSeqNum = seq;
00606 getHeader()->sequence = htons(seq);
00607 }
00608
00612 inline void
00613 setTimestamp(uint32 pts)
00614 {
00615 cachedTimestamp = pts;
00616 getHeader()->timestamp = htonl(pts);
00617 }
00618
00625 inline void
00626 setSSRC(uint32 ssrc) const
00627 { getHeader()->sources[0] = htonl(ssrc); }
00628
00636 inline void
00637 setSSRCNetwork(uint32 ssrc) const
00638 { getHeader()->sources[0] = ssrc; }
00639
00647 inline void
00648 setMarker(bool mark)
00649 { getHeader()->marker = mark; }
00650
00657 void protect(uint32 ssrc, CryptoContext* pcc);
00658
00662 inline bool
00663 operator==(const OutgoingRTPPkt &p) const
00664 { return ( this->getSeqNum() == p.getSeqNum() ); }
00665
00669 inline bool
00670 operator!=(const OutgoingRTPPkt &p) const
00671 { return ( this->getSeqNum() != p.getSeqNum() ); }
00672
00673 private:
00678 OutgoingRTPPkt(const OutgoingRTPPkt &o);
00679
00684 OutgoingRTPPkt&
00685 operator=(const OutgoingRTPPkt &o);
00686
00691 void setCSRCArray(const uint32* const csrcs, uint16 numcsrc);
00692
00693 };
00694
00707 class __EXPORT IncomingRTPPkt : public RTPPacket
00708 {
00709 public:
00722 IncomingRTPPkt(const unsigned char* block, size_t len);
00723
00724 ~IncomingRTPPkt()
00725 { }
00726
00732 inline bool
00733 isHeaderValid()
00734 { return headerValid; }
00735
00742 inline uint32
00743 getSSRC() const
00744 { return cachedSSRC; }
00745
00756 int32
00757 unprotect(CryptoContext* pcc);
00758
00763 inline bool
00764 operator==(const IncomingRTPPkt &p) const
00765 { return ( (this->getSeqNum() == p.getSeqNum()) &&
00766 (this->getSSRC() == p.getSSRC()) ); }
00767
00772 inline bool
00773 operator!=(const IncomingRTPPkt &p) const
00774 { return !( *this == p ); }
00775
00776 private:
00781 IncomingRTPPkt(const IncomingRTPPkt &ip);
00782
00787 IncomingRTPPkt&
00788 operator=(const IncomingRTPPkt &ip);
00789
00791 bool headerValid;
00793 uint32 cachedSSRC;
00794
00795
00796
00797 static const uint16 RTP_INVALID_PT_MASK;
00798 static const uint16 RTP_INVALID_PT_VALUE;
00799 };
00800
00802
00803 #ifdef CCXX_NAMESPACES
00804 }
00805 #endif
00806
00807 #endif // ndef CCXX_RTP_RTPPKT_H_
00808