重写rtp框架

src/Rtsp/RtpCodec.cpp

@@ -13,43 +13,37 @@
 namespace mediakit{
 
 RtpPacket::Ptr RtpInfo::makeRtp(TrackType type, const void* data, size_t len, bool mark, uint32_t stamp) {
-    uint16_t payload_len = (uint16_t)(len + 12);
-    uint32_t ts = htonl((_ui32SampleRate / 1000) * stamp);
-    uint16_t sq = htons(_ui16Sequence);
-    uint32_t sc = htonl(_ui32Ssrc);
+    uint16_t payload_len = (uint16_t) (len + RtpPacket::kRtpHeaderSize);
+    auto rtp = ResourcePoolHelper<RtpPacket>::obtainObj();
+    rtp->setCapacity(payload_len + RtpPacket::kRtpTcpHeaderSize);
+    rtp->setSize(payload_len + RtpPacket::kRtpTcpHeaderSize);
+    rtp->sample_rate = _sample_rate;
+    rtp->type = type;
 
-    auto rtp_ptr = ResourcePoolHelper<RtpPacket>::obtainObj();
-    rtp_ptr->setCapacity(len + 16);
-    rtp_ptr->setSize(len + 16);
+    //rtsp over tcp 头
+    auto ptr = (uint8_t *) rtp->data();
+    ptr[0] = '$';
+    ptr[1] = _interleaved;
+    ptr[2] = payload_len >> 8;
+    ptr[3] = payload_len & 0xFF;
 
-    auto *rtp = (unsigned char *)rtp_ptr->data();
-    rtp[0] = '$';
-    rtp[1] = _ui8Interleaved;
-    rtp[2] = payload_len >> 8;
-    rtp[3] = payload_len & 0xFF;
-    rtp[4] = 0x80;
-    rtp[5] = (mark << 7) | _ui8PayloadType;
-    memcpy(&rtp[6], &sq, 2);
-    memcpy(&rtp[8], &ts, 4);
-    //ssrc
-    memcpy(&rtp[12], &sc, 4);
+    //rtp头
+    auto header = rtp->getHeader();
+    header->version = RtpPacket::kRtpVersion;
+    header->padding = 0;
+    header->ext = 0;
+    header->csrc = 0;
+    header->mark = mark;
+    header->pt = _pt;
+    header->seq = htons(_seq++);
+    header->stamp = htonl(uint64_t(stamp) * _sample_rate / 1000);
+    header->ssrc = htonl(_ssrc);
 
-    if(data){
-        //payload
-        memcpy(&rtp[16], data, len);
+    //有效负载
+    if (data) {
+        memcpy(&ptr[RtpPacket::kRtpHeaderSize + RtpPacket::kRtpTcpHeaderSize], data, len);
     }
-
-    rtp_ptr->PT = _ui8PayloadType;
-    rtp_ptr->interleaved = _ui8Interleaved;
-    rtp_ptr->mark = mark;
-    rtp_ptr->sequence = _ui16Sequence;
-    rtp_ptr->timeStamp = stamp;
-    rtp_ptr->ssrc = _ui32Ssrc;
-    rtp_ptr->type = type;
-    rtp_ptr->offset = 16;
-    _ui16Sequence++;
-    _ui32TimeStamp = stamp;
-    return rtp_ptr;
+    return rtp;
 }
 
 }//namespace mediakit

src/Rtsp/RtpCodec.h

@@ -58,63 +58,41 @@ protected:
     RingType::Ptr _rtpRing;
 };
 
-
-class RtpInfo : public  ResourcePoolHelper<RtpPacket>{
+class RtpInfo : public ResourcePoolHelper<RtpPacket>{
 public:
     typedef std::shared_ptr<RtpInfo> Ptr;
 
-    RtpInfo(uint32_t ui32Ssrc,
-            uint32_t ui32MtuSize,
-            uint32_t ui32SampleRate,
-            uint8_t ui8PayloadType,
-            uint8_t ui8Interleaved) {
-        if(ui32Ssrc == 0){
-            ui32Ssrc = ((uint64_t)this) & 0xFFFFFFFF;
+    RtpInfo(uint32_t ssrc, size_t mtu_size, uint32_t sample_rate, uint8_t pt, uint8_t interleaved) {
+        if (ssrc == 0) {
+            ssrc = ((uint64_t) this) & 0xFFFFFFFF;
         }
-        _ui32Ssrc = ui32Ssrc;
-        _ui32SampleRate = ui32SampleRate;
-        _ui32MtuSize = ui32MtuSize;
-        _ui8PayloadType = ui8PayloadType;
-        _ui8Interleaved = ui8Interleaved;
+        _pt = pt;
+        _ssrc = ssrc;
+        _mtu_size = mtu_size;
+        _sample_rate = sample_rate;
+        _interleaved = interleaved;
     }
 
-    virtual ~RtpInfo(){}
+    ~RtpInfo() override {}
 
-    int getInterleaved() const {
-        return _ui8Interleaved;
-    }
-
-    int getPayloadType() const {
-        return _ui8PayloadType;
-    }
-
-    int getSampleRate() const {
-        return _ui32SampleRate;
+    //返回rtp负载最大长度
+    size_t getMaxSize() const {
+        return _mtu_size - RtpPacket::kRtpHeaderSize;
     }
 
     uint32_t getSsrc() const {
-        return _ui32Ssrc;
+        return _ssrc;
     }
 
-    uint16_t getSeqence() const {
-        return _ui16Sequence;
-    }
-    uint32_t getTimestamp() const {
-        return _ui32TimeStamp;
-    }
-    uint32_t getMtuSize() const {
-        return _ui32MtuSize;
-    }
     RtpPacket::Ptr makeRtp(TrackType type,const void *data, size_t len, bool mark, uint32_t stamp);
 
-protected:
-    uint32_t _ui32Ssrc;
-    uint32_t _ui32SampleRate;
-    uint32_t _ui32MtuSize;
-    uint8_t _ui8PayloadType;
-    uint8_t _ui8Interleaved;
-    uint16_t _ui16Sequence = 0;
-    uint32_t _ui32TimeStamp = 0;
+private:
+    uint8_t _pt;
+    uint8_t _interleaved;
+    uint16_t _seq = 0;
+    uint32_t _ssrc;
+    uint32_t _sample_rate;
+    size_t _mtu_size;
 };
 
 class RtpCodec : public RtpRing, public FrameDispatcher , public CodecInfo{

src/Rtsp/RtpReceiver.cpp

@@ -11,10 +11,6 @@
 #include "Common/config.h"
 #include "RtpReceiver.h"
 
-#define AV_RB16(x)                           \
-    ((((const uint8_t*)(x))[0] << 8) |          \
-      ((const uint8_t*)(x))[1])
-
 #define RTP_MAX_SIZE (10 * 1024)
 
 namespace mediakit {
@@ -28,122 +24,67 @@ RtpReceiver::RtpReceiver() {
         ++index;
     }
 }
+
 RtpReceiver::~RtpReceiver() {}
 
-bool RtpReceiver::handleOneRtp(int track_index, TrackType type, int samplerate, uint8_t *rtp_raw_ptr, size_t rtp_raw_len) {
-    if (rtp_raw_len < 12) {
-        WarnL << "rtp包太小:" << rtp_raw_len;
+bool RtpReceiver::handleOneRtp(int index, TrackType type, int sample_rate, uint8_t *ptr, size_t len) {
+    if (len < RtpPacket::kRtpHeaderSize) {
+        WarnL << "rtp包太小:" << len;
         return false;
     }
-
-    uint32_t version = rtp_raw_ptr[0] >> 6;
-    uint8_t padding = 0;
-    uint8_t ext = rtp_raw_ptr[0] & 0x10;
-    uint8_t csrc = rtp_raw_ptr[0] & 0x0f;
-
-    if (rtp_raw_ptr[0] & 0x20) {
-        //获取padding大小
-        padding = rtp_raw_ptr[rtp_raw_len - 1];
-        //移除padding flag
-        rtp_raw_ptr[0] &= ~0x20;
-        //移除padding字节
-        rtp_raw_len -= padding;
+    if (len > RTP_MAX_SIZE) {
+        WarnL << "超大的rtp包:" << len << " > " << RTP_MAX_SIZE;
+        return false;
     }
-
-    if (version != 2) {
-        throw std::invalid_argument("非法的rtp，version != 2");
-    }
-
-    auto rtp_ptr = _rtp_pool.obtain();
-    auto &rtp = *rtp_ptr;
-
-    rtp.type = type;
-    rtp.interleaved = 2 * type;
-    rtp.mark = rtp_raw_ptr[1] >> 7;
-    rtp.PT = rtp_raw_ptr[1] & 0x7F;
-
-    //序列号,内存对齐
-    memcpy(&rtp.sequence, rtp_raw_ptr + 2, 2);
-    rtp.sequence = ntohs(rtp.sequence);
-
-    //时间戳,内存对齐
-    memcpy(&rtp.timeStamp, rtp_raw_ptr + 4, 4);
-    rtp.timeStamp = ntohl(rtp.timeStamp);
-
-    if (!samplerate) {
+    if (!sample_rate) {
         //无法把时间戳转换成毫秒
         return false;
     }
-    //时间戳转换成毫秒
-    rtp.timeStamp = rtp.timeStamp * 1000LL / samplerate;
-
-    //ssrc,内存对齐
-    memcpy(&rtp.ssrc, rtp_raw_ptr + 8, 4);
-    rtp.ssrc = ntohl(rtp.ssrc);
-
-    if (_ssrc[track_index] != rtp.ssrc) {
-        if (_ssrc[track_index] == 0) {
-            //保存SSRC至track对象
-            _ssrc[track_index] = rtp.ssrc;
-        } else {
-            //ssrc错误
-            WarnL << "ssrc错误:" << rtp.ssrc << " != " << _ssrc[track_index];
-            if (_ssrc_err_count[track_index]++ > 10) {
-                //ssrc切换后清除老数据
-                WarnL << "ssrc更换:" << _ssrc[track_index] << " -> " << rtp.ssrc;
-                _rtp_sortor[track_index].clear();
-                _ssrc[track_index] = rtp.ssrc;
-            }
-            return false;
-        }
+    RtpHeader *header = (RtpHeader *) ptr;
+    if (header->version != RtpPacket::kRtpVersion) {
+        throw std::invalid_argument("非法的rtp，version字段非法");
     }
-
-    //ssrc匹配正确，不匹配计数清零
-    _ssrc_err_count[track_index] = 0;
-
-    //rtp 12个固定字节头
-    rtp.offset = 12;
-    //rtp有csrc
-    rtp.offset += 4 * csrc;
-    if (ext) {
-        //rtp有ext
-        uint16_t reserved = AV_RB16(rtp_raw_ptr + rtp.offset);
-        uint16_t extlen = AV_RB16(rtp_raw_ptr + rtp.offset + 2) << 2;
-        rtp.offset += extlen + 4;
-    }
-
-    if (rtp_raw_len <= rtp.offset) {
+    if (!header->getPayloadSize(len)) {
         //无有效负载的rtp包
         return false;
     }
 
-    if (rtp_raw_len > RTP_MAX_SIZE) {
-        WarnL << "超大的rtp包:" << rtp_raw_len << " > " << RTP_MAX_SIZE;
+    //比对缓存ssrc
+    auto ssrc = ntohl(header->ssrc);
+
+    if (!_ssrc[index]) {
+        //保存SSRC至track对象
+        _ssrc[index] = ssrc;
+    } else if (_ssrc[index] != ssrc) {
+        //ssrc错误
+        WarnL << "ssrc错误:" << ssrc << " != " << _ssrc[index];
         return false;
     }
 
-    //设置rtp负载长度
-    rtp.setCapacity(rtp_raw_len + 4);
-    rtp.setSize(rtp_raw_len + 4);
-    uint8_t *payload_ptr = (uint8_t *) rtp.data();
-    payload_ptr[0] = '$';
-    payload_ptr[1] = rtp.interleaved;
-    payload_ptr[2] = (rtp_raw_len >> 8) & 0xFF;
-    payload_ptr[3] = rtp_raw_len & 0xFF;
-    //添加rtp over tcp前4个字节的偏移量
-    rtp.offset += 4;
-    //拷贝rtp负载
-    memcpy(payload_ptr + 4, rtp_raw_ptr, rtp_raw_len);
-    //排序rtp
-    auto seq = rtp_ptr->sequence;
-    onBeforeRtpSorted(rtp_ptr, track_index);
-    _rtp_sortor[track_index].sortPacket(seq, std::move(rtp_ptr));
+    auto rtp = _rtp_pool.obtain();
+    //需要添加4个字节的rtp over tcp头
+    rtp->setCapacity(RtpPacket::kRtpTcpHeaderSize + len);
+    rtp->setSize(RtpPacket::kRtpTcpHeaderSize + len);
+    rtp->sample_rate = sample_rate;
+    rtp->type = type;
+
+    //赋值4个字节的rtp over tcp头
+    uint8_t *data = (uint8_t *) rtp->data();
+    data[0] = '$';
+    data[1] = 2 * type;
+    data[2] = (len >> 8) & 0xFF;
+    data[3] = len & 0xFF;
+    //拷贝rtp
+    memcpy(&data[4], ptr, len);
+
+    onBeforeRtpSorted(rtp, index);
+    auto seq = rtp->getSeq();
+    _rtp_sortor[index].sortPacket(seq, std::move(rtp));
     return true;
 }
 
 void RtpReceiver::clear() {
     CLEAR_ARR(_ssrc);
-    CLEAR_ARR(_ssrc_err_count);
     for (auto &sortor : _rtp_sortor) {
         sortor.clear();
     }
@@ -153,16 +94,16 @@ void RtpReceiver::setPoolSize(size_t size) {
     _rtp_pool.setSize(size);
 }
 
-size_t RtpReceiver::getJitterSize(int track_index) const{
-    return _rtp_sortor[track_index].getJitterSize();
+size_t RtpReceiver::getJitterSize(int index) const{
+    return _rtp_sortor[index].getJitterSize();
 }
 
-size_t RtpReceiver::getCycleCount(int track_index) const{
-    return _rtp_sortor[track_index].getCycleCount();
+size_t RtpReceiver::getCycleCount(int index) const{
+    return _rtp_sortor[index].getCycleCount();
 }
 
-uint32_t RtpReceiver::getSSRC(int track_index) const{
-    return _ssrc[track_index];
+uint32_t RtpReceiver::getSSRC(int index) const{
+    return _ssrc[index];
 }
 
 }//namespace mediakit

src/Rtsp/RtpReceiver.h

@@ -168,14 +168,14 @@ public:
 protected:
     /**
      * 输入数据指针生成并排序rtp包
-     * @param track_index track下标索引
+     * @param index track下标索引
      * @param type track类型
      * @param samplerate rtp时间戳基准时钟，视频为90000，音频为采样率
-     * @param rtp_raw_ptr rtp数据指针
-     * @param rtp_raw_len rtp数据指针长度
+     * @param ptr rtp数据指针
+     * @param len rtp数据指针长度
      * @return 解析成功返回true
      */
-    bool handleOneRtp(int track_index, TrackType type, int samplerate, uint8_t *rtp_raw_ptr, size_t rtp_raw_len);
+    bool handleOneRtp(int index, TrackType type, int samplerate, uint8_t *ptr, size_t len);
 
     /**
      * rtp数据包排序后输出
@@ -199,8 +199,6 @@ protected:
 
 private:
     uint32_t _ssrc[2] = {0, 0};
-    //ssrc不匹配计数
-    size_t _ssrc_err_count[2] = {0, 0};
     //rtp排序缓存，根据seq排序
     PacketSortor<RtpPacket::Ptr> _rtp_sortor[2];
     //rtp循环池

src/Rtsp/Rtsp.cpp

@@ -415,14 +415,101 @@ string printSSRC(uint32_t ui32Ssrc) {
 }
 
 Buffer::Ptr makeRtpOverTcpPrefix(uint16_t size, uint8_t interleaved){
-    auto rtp_tcp = std::make_shared<BufferRaw>(4);
+    auto rtp_tcp = std::make_shared<BufferRaw>(RtpPacket::kRtpTcpHeaderSize);
+    rtp_tcp->setSize(RtpPacket::kRtpTcpHeaderSize);
     auto ptr = rtp_tcp->data();
     ptr[0] = '$';
     ptr[1] = interleaved;
     ptr[2] = (size >> 8) & 0xFF;
     ptr[3] = size & 0xFF;
-    rtp_tcp->setSize(4);
     return rtp_tcp;
 }
 
+#define AV_RB16(x)                           \
+    ((((const uint8_t*)(x))[0] << 8) |          \
+      ((const uint8_t*)(x))[1])
+
+size_t RtpHeader::getCsrcSize() const {
+    //每个csrc占用4字节
+    return csrc << 2;
+}
+
+uint8_t *RtpHeader::getCsrcData() {
+    if (!csrc) {
+        return nullptr;
+    }
+    return &payload;
+}
+
+size_t RtpHeader::getExtSize() const {
+    //rtp有ext
+    if (!ext) {
+        return 0;
+    }
+    auto ext_ptr = &payload + getCsrcSize();
+    uint16_t reserved = AV_RB16(ext_ptr);
+    //每个ext占用4字节
+    return AV_RB16(ext_ptr + 2) << 2;
+}
+
+uint8_t *RtpHeader::getExtData() {
+    if (!ext) {
+        return nullptr;
+    }
+    auto ext_ptr = &payload + getCsrcSize();
+    //多出的4个字节分别为reserved、ext_len
+    return ext_ptr + 4 + getExtSize();
+}
+
+size_t RtpHeader::getPayloadOffset() const {
+    //有ext时，还需要忽略reserved、ext_len 4个字节
+    return getCsrcSize() + (ext ? (4 + getExtSize()) : 0);
+}
+
+uint8_t *RtpHeader::getPayloadData() {
+    return &payload + getPayloadOffset();
+}
+
+size_t RtpHeader::getPaddingSize(size_t rtp_size) const {
+    if (!padding) {
+        return 0;
+    }
+    auto end = (uint8_t *) this + rtp_size;
+    return *end;
+}
+
+size_t RtpHeader::getPayloadSize(size_t rtp_size){
+    auto invalid_size = getPayloadOffset() + getPaddingSize(rtp_size);
+    if (invalid_size + RtpPacket::kRtpHeaderSize >= rtp_size) {
+        return 0;
+    }
+    return rtp_size - invalid_size - RtpPacket::kRtpHeaderSize;
+}
+
+RtpHeader* RtpPacket::getHeader(){
+    //需除去rtcp over tcp 4个字节长度
+    return (RtpHeader*)(data() + RtpPacket::kRtpTcpHeaderSize);
+}
+
+uint16_t RtpPacket::getSeq(){
+    return ntohs(getHeader()->seq);
+}
+
+uint32_t RtpPacket::getStampMS(){
+    return ntohl(getHeader()->stamp) * uint64_t(1000) / sample_rate;
+}
+
+uint32_t RtpPacket::getSSRC(){
+    return ntohl(getHeader()->ssrc);
+}
+
+uint8_t* RtpPacket::getPayload(){
+    return getHeader()->getPayloadData();
+}
+
+size_t RtpPacket::getPayloadSize(){
+    //需除去rtcp over tcp 4个字节长度
+    return getHeader()->getPayloadSize(size() - kRtpTcpHeaderSize);
+}
+
 }//namespace mediakit

src/Rtsp/Rtsp.h

@@ -15,8 +15,9 @@
 #include <string>
 #include <memory>
 #include <unordered_map>
-#include "Common/config.h"
 #include "Util/util.h"
+#include "Common/config.h"
+#include "Common/macros.h"
 #include "Extension/Frame.h"
 
 using namespace std;
@@ -68,18 +69,101 @@ typedef enum {
 
 };
 
+#if defined(_WIN32)
+#pragma pack(push, 1)
+#endif // defined(_WIN32)
+
+class RtpHeader {
+public:
+#if __BYTE_ORDER == __BIG_ENDIAN
+    //版本号，固定为2
+    uint32_t version: 2;
+    //padding
+    uint32_t padding: 1;
+    //扩展
+    uint32_t ext: 1;
+    //csrc
+    uint32_t csrc: 4;
+    //mark
+    uint32_t mark: 1;
+    //负载类型
+    uint32_t pt: 7;
+#else
+    //csrc
+    uint32_t csrc: 4;
+    //扩展
+    uint32_t ext: 1;
+    //padding
+    uint32_t padding: 1;
+    //版本号，固定为2
+    uint32_t version: 2;
+    //负载类型
+    uint32_t pt: 7;
+    //mark
+    uint32_t mark: 1;
+#endif
+    //序列号
+    uint32_t seq: 16;
+    //时间戳
+    uint32_t stamp;
+    //ssrc
+    uint32_t ssrc;
+    //负载，如果有csrc和ext，前面为 4 * csrc + (4 + 4 * ext_len)
+    uint8_t payload;
+
+public:
+    //返回csrc字段字节长度
+    size_t getCsrcSize() const;
+    //返回csrc字段首地址，不存在时返回nullptr
+    uint8_t *getCsrcData();
+
+    //返回ext字段字节长度
+    size_t getExtSize() const;
+    //返回ext段首地址，不存在时返回nullptr
+    uint8_t *getExtData();
+
+    //返回有效负载指针,跳过csrc、ext
+    uint8_t* getPayloadData();
+    //返回有效负载总长度,不包括csrc、ext、padding
+    size_t getPayloadSize(size_t rtp_size);
+
+private:
+    //返回有效负载偏移量
+    size_t getPayloadOffset() const;
+    //返回padding长度
+    size_t getPaddingSize(size_t rtp_size) const;
+} PACKED;
+
+#if defined(_WIN32)
+#pragma pack(pop)
+#endif // defined(_WIN32)
+
+//此rtp为rtp over tcp形式，需要忽略前4个字节
 class RtpPacket : public BufferRaw{
 public:
-    typedef std::shared_ptr<RtpPacket> Ptr;
-    bool mark;
-    uint8_t interleaved;
-    uint8_t PT;
+    using Ptr = std::shared_ptr<RtpPacket>;
+    enum {
+        kRtpVersion = 2,
+        kRtpHeaderSize = 12,
+        kRtpTcpHeaderSize = 4
+    };
+
+    RtpHeader* getHeader();
+    //主机字节序的seq
+    uint16_t getSeq();
+    //主机字节序的时间戳，已经转换为毫秒
+    uint32_t getStampMS();
+    //主机字节序的ssrc
+    uint32_t getSSRC();
+    //有效负载，跳过csrc、ext
+    uint8_t* getPayload();
+    //有效负载长度，不包括csrc、ext、padding
+    size_t getPayloadSize();
+
+    //音视频类型
     TrackType type;
-    uint16_t sequence;
-    //时间戳，单位毫秒
-    uint32_t timeStamp;
-    uint32_t ssrc;
-    size_t offset;
+    //音频为采样率，视频一般为90000
+    uint32_t sample_rate;
 };
 
 Buffer::Ptr makeRtpOverTcpPrefix(uint16_t size, uint8_t interleaved);

src/Rtsp/RtspMediaSource.h

@@ -160,10 +160,11 @@ public:
         _speed[rtp->type] += rtp->size();
         assert(rtp->type >= 0 && rtp->type < TrackMax);
         auto &track = _tracks[rtp->type];
+        auto stamp = rtp->getStampMS();
         if (track) {
-            track->_seq = rtp->sequence;
-            track->_time_stamp = rtp->timeStamp;
-            track->_ssrc = rtp->ssrc;
+            track->_seq = rtp->getSeq();
+            track->_time_stamp = stamp;
+            track->_ssrc = rtp->getSSRC();
         }
         if (!_ring) {
             weak_ptr<RtspMediaSource> weakSelf = dynamic_pointer_cast<RtspMediaSource>(shared_from_this());
@@ -183,7 +184,6 @@ public:
             }
         }
         bool is_video = rtp->type == TrackVideo;
-        auto stamp = rtp->timeStamp;
         PacketCache<RtpPacket>::inputPacket(stamp, is_video, std::move(rtp), keyPos);
     }
 

src/Rtsp/RtspPlayer.cpp

@@ -478,10 +478,10 @@ void RtspPlayer::onRtpPacket(const char *data, size_t len) {
     uint8_t interleaved = data[1];
     if(interleaved %2 == 0){
         trackIdx = getTrackIndexByInterleaved(interleaved);
-        handleOneRtp(trackIdx, _sdp_track[trackIdx]->_type, _sdp_track[trackIdx]->_samplerate, (uint8_t *)data + 4, len - 4);
+        handleOneRtp(trackIdx, _sdp_track[trackIdx]->_type, _sdp_track[trackIdx]->_samplerate, (uint8_t *)data + RtpPacket::kRtpTcpHeaderSize, len - RtpPacket::kRtpTcpHeaderSize);
     }else{
         trackIdx = getTrackIndexByInterleaved(interleaved - 1);
-        onRtcpPacket(trackIdx, _sdp_track[trackIdx], (uint8_t *) data + 4, len - 4);
+        onRtcpPacket(trackIdx, _sdp_track[trackIdx], (uint8_t *) data + RtpPacket::kRtpTcpHeaderSize, len - RtpPacket::kRtpTcpHeaderSize);
     }
 }
 
@@ -494,7 +494,7 @@ void RtspPlayer::onRtcpPacket(int track_idx, SdpTrack::Ptr &track, uint8_t *data
 }
 
 void RtspPlayer::onRtpSorted(const RtpPacket::Ptr &rtppt, int trackidx){
-    _stamp[trackidx] = rtppt->timeStamp;
+    _stamp[trackidx] = rtppt->getStampMS();
     _rtp_recv_ticker.resetTime();
     onRecvRTP(rtppt, _sdp_track[trackidx]);
 }
@@ -593,7 +593,7 @@ void RtspPlayer::sendRtspRequest(const string &cmd, const string &url,const StrC
 
 void RtspPlayer::onBeforeRtpSorted(const RtpPacket::Ptr &rtp, int track_idx){
     auto &rtcp_ctx = _rtcp_context[track_idx];
-    rtcp_ctx->onRtp(rtp->sequence, rtp->timeStamp, rtp->size() - 4);
+    rtcp_ctx->onRtp(rtp->getSeq(), rtp->getStampMS(), rtp->size() - RtpPacket::kRtpTcpHeaderSize);
 
     auto &ticker = _rtcp_send_ticker[track_idx];
     if (ticker.elapsedTime() < 3 * 1000) {
@@ -627,10 +627,11 @@ void RtspPlayer::onBeforeRtpSorted(const RtpPacket::Ptr &rtp, int track_idx){
         }
     };
 
-    auto rtcp = rtcp_ctx->createRtcpRR(rtp->ssrc + 1, rtp->ssrc);
+    auto ssrc = rtp->getSSRC();
+    auto rtcp = rtcp_ctx->createRtcpRR(ssrc + 1, ssrc);
     auto rtcp_sdes = RtcpSdes::create({SERVER_NAME});
     rtcp_sdes->items.type = (uint8_t) SdesType::RTCP_SDES_CNAME;
-    rtcp_sdes->items.ssrc = htonl(rtp->ssrc);
+    rtcp_sdes->items.ssrc = htonl(ssrc);
     send_rtcp(this, track_idx, std::move(rtcp));
     send_rtcp(this, track_idx, RtcpHeader::toBuffer(rtcp_sdes));
     ticker.resetTime();

src/Rtsp/RtspPusher.cpp

@@ -154,7 +154,7 @@ void RtspPusher::onRtpPacket(const char *data, size_t len) {
     uint8_t interleaved = data[1];
     if (interleaved % 2 != 0) {
         trackIdx = getTrackIndexByInterleaved(interleaved - 1);
-        onRtcpPacket(trackIdx, _track_vec[trackIdx], (uint8_t *) data + 4, len - 4);
+        onRtcpPacket(trackIdx, _track_vec[trackIdx], (uint8_t *) data + RtpPacket::kRtpTcpHeaderSize, len - RtpPacket::kRtpTcpHeaderSize);
     }
 }
 
@@ -361,7 +361,7 @@ void RtspPusher::updateRtcpContext(const RtpPacket::Ptr &rtp){
     int track_index = getTrackIndexByTrackType(rtp->type);
     auto &ticker = _rtcp_send_ticker[track_index];
     auto &rtcp_ctx = _rtcp_context[track_index];
-    rtcp_ctx->onRtp(rtp->sequence, rtp->timeStamp, rtp->size() - 4);
+    rtcp_ctx->onRtp(rtp->getSeq(), rtp->getStampMS(), rtp->size() - RtpPacket::kRtpTcpHeaderSize);
 
     //send rtcp every 5 second
     if (ticker.elapsedTime() > 5 * 1000) {
@@ -376,10 +376,11 @@ void RtspPusher::updateRtcpContext(const RtpPacket::Ptr &rtp){
             }
         };
 
-        auto rtcp = rtcp_ctx->createRtcpSR(rtp->ssrc + 1);
+        auto ssrc = rtp->getSSRC();
+        auto rtcp = rtcp_ctx->createRtcpSR(ssrc + 1);
         auto rtcp_sdes = RtcpSdes::create({SERVER_NAME});
         rtcp_sdes->items.type = (uint8_t) SdesType::RTCP_SDES_CNAME;
-        rtcp_sdes->items.ssrc = htonl(rtp->ssrc);
+        rtcp_sdes->items.ssrc = htonl(ssrc);
         send_rtcp(this, track_index, std::move(rtcp));
         send_rtcp(this, track_index, RtcpHeader::toBuffer(rtcp_sdes));
     }

src/Rtsp/RtspSession.cpp

@@ -15,7 +15,6 @@
 #include "RtspSession.h"
 #include "Util/MD5.h"
 #include "Util/base64.h"
-#include "Rtcp/Rtcp.h"
 
 using namespace std;
 using namespace toolkit;
@@ -171,10 +170,10 @@ void RtspSession::onRtpPacket(const char *data, size_t len) {
             return;
         }
         auto track_idx = getTrackIndexByInterleaved(interleaved);
-        handleOneRtp(track_idx, _sdp_track[track_idx]->_type, _sdp_track[track_idx]->_samplerate, (uint8_t *) data + 4, len - 4);
+        handleOneRtp(track_idx, _sdp_track[track_idx]->_type, _sdp_track[track_idx]->_samplerate, (uint8_t *) data + RtpPacket::kRtpTcpHeaderSize, len - RtpPacket::kRtpTcpHeaderSize);
     } else {
         auto track_idx = getTrackIndexByInterleaved(interleaved - 1);
-        onRtcpPacket(track_idx, _sdp_track[track_idx], data + 4, len - 4);
+        onRtcpPacket(track_idx, _sdp_track[track_idx], data + RtpPacket::kRtpTcpHeaderSize, len - RtpPacket::kRtpTcpHeaderSize);
     }
 }
 
@@ -913,12 +912,6 @@ void RtspSession::send_NotAcceptable() {
 }
 
 void RtspSession::onRtpSorted(const RtpPacket::Ptr &rtp, int track_idx) {
-    if (_start_stamp[track_idx] == -1) {
-        //记录起始时间戳
-        _start_stamp[track_idx] = rtp->timeStamp;
-    }
-    //时间戳增量
-    rtp->timeStamp -= _start_stamp[track_idx];
     _push_src->onWrite(rtp, false);
 }
 
@@ -1130,7 +1123,7 @@ void RtspSession::onBeforeRtpSorted(const RtpPacket::Ptr &rtp, int track_index){
 void RtspSession::updateRtcpContext(const RtpPacket::Ptr &rtp){
     int track_index = getTrackIndexByTrackType(rtp->type);
     auto &rtcp_ctx = _rtcp_context[track_index];
-    rtcp_ctx->onRtp(rtp->sequence, rtp->timeStamp, rtp->size() - 4);
+    rtcp_ctx->onRtp(rtp->getSeq(), rtp->getStampMS(), rtp->size() - RtpPacket::kRtpTcpHeaderSize);
 
     auto &ticker = _rtcp_send_tickers[track_index];
     //send rtcp every 5 second
@@ -1147,10 +1140,11 @@ void RtspSession::updateRtcpContext(const RtpPacket::Ptr &rtp){
             }
         };
 
-        auto rtcp = _push_src ?  rtcp_ctx->createRtcpRR(rtp->ssrc + 1, rtp->ssrc) : rtcp_ctx->createRtcpSR(rtp->ssrc + 1);
+        auto ssrc = rtp->getSSRC();
+        auto rtcp = _push_src ?  rtcp_ctx->createRtcpRR(ssrc + 1, ssrc) : rtcp_ctx->createRtcpSR(ssrc + 1);
         auto rtcp_sdes = RtcpSdes::create({SERVER_NAME});
         rtcp_sdes->items.type = (uint8_t)SdesType::RTCP_SDES_CNAME;
-        rtcp_sdes->items.ssrc = htonl(rtp->ssrc);
+        rtcp_sdes->items.ssrc = htonl(ssrc);
         send_rtcp(this, track_index, std::move(rtcp));
         send_rtcp(this, track_index, RtcpHeader::toBuffer(rtcp_sdes));
     }

src/Rtsp/RtspSession.h

@@ -171,8 +171,6 @@ private:
     Rtsp::eRtpType _rtp_type = Rtsp::RTP_Invalid;
     //收到的seq，回复时一致
     int _cseq = 0;
-    //rtsp推流起始时间戳，目的是为了同步
-    int32_t _start_stamp[2] = {-1, -1};
     //消耗的总流量
     uint64_t _bytes_usage = 0;
     //ContentBase