Merge remote-tracking branch 'john/rtc' into feature/rtc

trunk/conf/full.conf

@@ -438,6 +438,9 @@ vhost rtc.vhost.srs.com {
         # Client will send ping(STUN binding request) to server, we use it as heartbeat.
         # default: 30
         stun_timeout    30;
+        # The strick check when process stun.
+        # default: off
+        stun_strict_check on;
     }
     # whether enable min delay mode for vhost.
     # For RTC, we recommend to set to on.

trunk/src/app/srs_app_config.cpp

@@ -3876,7 +3876,7 @@ srs_error_t SrsConfig::check_normal_config()
             } else if (n == "rtc") {
                 for (int j = 0; j < (int)conf->directives.size(); j++) {
                     string m = conf->at(j)->name;
-                    if (m != "enabled" && m != "bframe" && m != "aac" && m != "stun_timeout") {
+                    if (m != "enabled" && m != "bframe" && m != "aac" && m != "stun_timeout" && m != "stun_strict_check") {
                         return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "illegal vhost.rtc.%s of %s", m.c_str(), vhost->arg0().c_str());
                     }
                 }
@@ -4798,6 +4798,24 @@ srs_utime_t SrsConfig::get_rtc_stun_timeout(string vhost)
     return (srs_utime_t)(::atoi(conf->arg0().c_str()) * SRS_UTIME_SECONDS);
 }
 
+bool SrsConfig::get_rtc_stun_strict_check(string vhost)
+{
+    static bool DEFAULT = false;
+
+    SrsConfDirective* conf = get_rtc(vhost);
+
+    if (!conf) {
+        return DEFAULT;
+    }
+
+    conf = conf->get("stun_strict_check");
+    if (!conf || conf->arg0().empty()) {
+        return DEFAULT;
+    }
+
+    return SRS_CONF_PERFER_FALSE(conf->arg0());
+}
+
 SrsConfDirective* SrsConfig::get_vhost(string vhost, bool try_default_vhost)
 {
     srs_assert(root);

trunk/src/app/srs_app_config.hpp

@@ -531,6 +531,7 @@ public:
     bool get_rtc_bframe_discard(std::string vhost);
     bool get_rtc_aac_discard(std::string vhost);
     srs_utime_t get_rtc_stun_timeout(std::string vhost);
+    bool get_rtc_stun_strict_check(std::string vhost);
 
 // vhost specified section
 public:

trunk/src/app/srs_app_http_api.cpp

@@ -1011,26 +1011,40 @@ srs_error_t SrsGoApiRtcPlay::exchange_sdp(const std::string& app, const std::str
             }
 
             if (local_media_desc.payload_types_.empty()) {
-                return srs_error_new(ERROR_RTC_SDP_EXCHANGE, "no valid found opus payload type");
+                return srs_error_new(ERROR_RTC_SDP_EXCHANGE, "no found valid opus payload type");
             }
 
         } else if (remote_media_desc.is_video()) {
+            std::deque<SrsMediaPayloadType> backup_payloads;
             std::vector<SrsMediaPayloadType> payloads = remote_media_desc.find_media_with_encoding_name("H264");
             for (std::vector<SrsMediaPayloadType>::iterator iter = payloads.begin(); iter != payloads.end(); ++iter) {
+                if (iter->format_specific_param_.empty()) {
+                    backup_payloads.push_front(*iter);
+                    continue;
+                }
                 H264SpecificParam h264_param;
                 if ((err = parse_h264_fmtp(iter->format_specific_param_, h264_param)) != srs_success) {
                     srs_error_reset(err); continue;
                 }
 
-                if (h264_param.packetization_mode == 1 && h264_param.level_asymmerty_allow == 1) {
+                // Try to pick the "best match" H.264 payload type.
+                if (h264_param.packetization_mode == "1" && h264_param.level_asymmerty_allow == "1") {
                     // Only choose first match H.264 payload type.
                     local_media_desc.payload_types_.push_back(*iter);
                     break;
                 }
+
+                backup_payloads.push_back(*iter);
+            }
+
+            // Try my best to pick at least one media payload type.
+            if (local_media_desc.payload_types_.empty() && ! backup_payloads.empty()) {
+                srs_warn("choose backup H.264 payload type=%d", backup_payloads.front().payload_type_);
+                local_media_desc.payload_types_.push_back(backup_payloads.front());
             }
 
             if (local_media_desc.payload_types_.empty()) {
-                return srs_error_new(ERROR_RTC_SDP_EXCHANGE, "no valid found H.264 payload type");
+                return srs_error_new(ERROR_RTC_SDP_EXCHANGE, "no found valid H.264 payload type");
             }
         }
 

trunk/src/app/srs_app_pithy_print.cpp

@@ -110,6 +110,8 @@ SrsPithyPrint::SrsPithyPrint(int _stage_id)
 #define SRS_CONSTS_STAGE_HTTP_STREAM_CACHE 10
 // for the ng-exec stage.
 #define SRS_CONSTS_STAGE_EXEC 11
+// for the rtc play
+#define SRS_CONSTS_STAGE_RTC_PLAY 12
 
 SrsPithyPrint* SrsPithyPrint::create_rtmp_play()
 {
@@ -166,6 +168,11 @@ SrsPithyPrint* SrsPithyPrint::create_http_stream_cache()
     return new SrsPithyPrint(SRS_CONSTS_STAGE_HTTP_STREAM_CACHE);
 }
 
+SrsPithyPrint* SrsPithyPrint::create_rtc_play()
+{
+    return new SrsPithyPrint(SRS_CONSTS_STAGE_RTC_PLAY);
+}
+
 SrsPithyPrint::~SrsPithyPrint()
 {
     leave_stage();

trunk/src/app/srs_app_pithy_print.hpp

@@ -87,6 +87,7 @@ public:
     static SrsPithyPrint* create_caster();
     static SrsPithyPrint* create_http_stream();
     static SrsPithyPrint* create_http_stream_cache();
+    static SrsPithyPrint* create_rtc_play();
     virtual ~SrsPithyPrint();
 private:
     // Enter the specified stage, return the client id.

trunk/src/app/srs_app_rtc.cpp

@@ -160,7 +160,7 @@ srs_error_t SrsRtpH264Muxer::frame_to_packet(SrsSharedPtrMessage* shared_frame,
     if (! rtp_packet_vec.empty()) {
         // At the end of the frame, set marker bit.
         // One frame may have multi nals. Set the marker bit in the last nal end, no the end of the nal.
-        if ((err = rtp_packet_vec.back()->set_marker(true)) != srs_success) {
+        if ((err = rtp_packet_vec.back()->modify_rtp_header_marker(true)) != srs_success) {
             return srs_error_wrap(err, "set marker");
         }
     }
@@ -187,23 +187,12 @@ srs_error_t SrsRtpH264Muxer::packet_fu_a(SrsSharedPtrMessage* shared_frame, SrsF
 
     int num_of_packet = (sample->size - 1 + kRtpMaxPayloadSize) / kRtpMaxPayloadSize;
     for (int i = 0; i < num_of_packet; ++i) {
-        char* buf = new char[kRtpPacketSize];
+        char buf[kRtpPacketSize];
         SrsBuffer* stream = new SrsBuffer(buf, kRtpPacketSize);
         SrsAutoFree(SrsBuffer, stream);
 
         int packet_size = min(nb_left, kRtpMaxPayloadSize);
 
-        // v=2,p=0,x=0,cc=0
-        stream->write_1bytes(0x80);
-        // marker payloadtype
-        stream->write_1bytes(kH264PayloadType);
-        // sequence
-        stream->write_2bytes(sequence);
-        // timestamp
-        stream->write_4bytes(int32_t(shared_frame->timestamp * 90));
-        // ssrc
-        stream->write_4bytes(int32_t(kVideoSSRC));
-
         // fu-indicate
         uint8_t fu_indicate = kFuA;
         fu_indicate |= (header & (~kNalTypeMask));
@@ -223,7 +212,9 @@ srs_error_t SrsRtpH264Muxer::packet_fu_a(SrsSharedPtrMessage* shared_frame, SrsF
         srs_verbose("rtp fu-a nalu, size=%u, seq=%u, timestamp=%lu", sample->size, sequence, (shared_frame->timestamp * 90));
 
         SrsRtpSharedPacket* rtp_shared_pkt = new SrsRtpSharedPacket();
-        rtp_shared_pkt->create((shared_frame->timestamp * 90), sequence++, kVideoSSRC, kH264PayloadType, stream->data(), stream->pos());
+        if ((err = rtp_shared_pkt->create((shared_frame->timestamp * 90), sequence++, kVideoSSRC, kH264PayloadType, stream->data(), stream->pos())) != srs_success) {
+            return srs_error_wrap(err, "rtp packet encode");
+        }
 
         rtp_packet_vec.push_back(rtp_shared_pkt);
     }
@@ -238,9 +229,6 @@ srs_error_t SrsRtpH264Muxer::packet_single_nalu(SrsSharedPtrMessage* shared_fram
     uint8_t header = sample->bytes[0];
     uint8_t nal_type = header & kNalTypeMask;
 
-    char* buf = new char[kRtpPacketSize];
-    SrsBuffer* stream = new SrsBuffer(buf, kRtpPacketSize);
-    SrsAutoFree(SrsBuffer, stream);
 
     if (nal_type == SrsAvcNaluTypeIDR) {
         if ((err = packet_stap_a(sps, pps, shared_frame, rtp_packet_vec)) != srs_success) {
@@ -248,23 +236,12 @@ srs_error_t SrsRtpH264Muxer::packet_single_nalu(SrsSharedPtrMessage* shared_fram
         }
     }
 
-    // v=2,p=0,x=0,cc=0
-    stream->write_1bytes(0x80);
-    // marker payloadtype
-    stream->write_1bytes(kH264PayloadType);
-    // sequenct
-    stream->write_2bytes(sequence);
-    // timestamp
-    stream->write_4bytes(int32_t(shared_frame->timestamp * 90));
-    // ssrc
-    stream->write_4bytes(int32_t(kVideoSSRC));
-
-    stream->write_bytes(sample->bytes, sample->size);
-
     srs_verbose("rtp single nalu, size=%u, seq=%u, timestamp=%lu", sample->size, sequence, (shared_frame->timestamp * 90));
 
     SrsRtpSharedPacket* rtp_shared_pkt = new SrsRtpSharedPacket();
-    rtp_shared_pkt->create((shared_frame->timestamp * 90), sequence++, kVideoSSRC, kH264PayloadType, stream->data(), stream->pos());
+    if ((err = rtp_shared_pkt->create((shared_frame->timestamp * 90), sequence++, kVideoSSRC, kH264PayloadType, sample->bytes, sample->size)) != srs_success) {
+        return srs_error_wrap(err, "rtp packet encode");
+    }
 
     rtp_packet_vec.push_back(rtp_shared_pkt);
 
@@ -282,21 +259,10 @@ srs_error_t SrsRtpH264Muxer::packet_stap_a(const string &sps, const string& pps,
     uint8_t header = sps[0];
     uint8_t nal_type = header & kNalTypeMask;
 
-    char* buf = new char[kRtpPacketSize];
+    char buf[kRtpPacketSize];
     SrsBuffer* stream = new SrsBuffer(buf, kRtpPacketSize);
     SrsAutoFree(SrsBuffer, stream);
 
-    // v=2,p=0,x=0,cc=0
-    stream->write_1bytes(0x80);
-    // marker payloadtype
-    stream->write_1bytes(kH264PayloadType);
-    // sequenct
-    stream->write_2bytes(sequence);
-    // timestamp
-    stream->write_4bytes(int32_t(shared_frame->timestamp * 90));
-    // ssrc
-    stream->write_4bytes(int32_t(kVideoSSRC));
-
     // stap-a header
     uint8_t stap_a_header = kStapA;
     stap_a_header |= (nal_type & (~kNalTypeMask));
@@ -311,7 +277,9 @@ srs_error_t SrsRtpH264Muxer::packet_stap_a(const string &sps, const string& pps,
     srs_verbose("rtp stap-a nalu, size=%u, seq=%u, timestamp=%lu", (sps.size() + pps.size()), sequence, (shared_frame->timestamp * 90));
 
     SrsRtpSharedPacket* rtp_shared_pkt = new SrsRtpSharedPacket();
-    rtp_shared_pkt->create((shared_frame->timestamp * 90), sequence++, kVideoSSRC, kH264PayloadType, stream->data(), stream->pos());
+    if ((err = rtp_shared_pkt->create((shared_frame->timestamp * 90), sequence++, kVideoSSRC, kH264PayloadType, stream->data(), stream->pos())) != srs_success) {
+        return srs_error_wrap(err, "rtp packet encode");
+    }
 
     rtp_packet_vec.push_back(rtp_shared_pkt);
 
@@ -385,28 +353,14 @@ srs_error_t SrsRtpOpusMuxer::packet_opus(SrsSharedPtrMessage* shared_frame, SrsS
 {
     srs_error_t err = srs_success;
 
-    char* buf = new char[kRtpPacketSize];
+    SrsRtpSharedPacket* rtp_shared_pkt = new SrsRtpSharedPacket();
-    SrsBuffer* stream = new SrsBuffer(buf, kRtpPacketSize);
+    rtp_shared_pkt->rtp_header.set_marker(true);
-    SrsAutoFree(SrsBuffer, stream);
+    if ((err = rtp_shared_pkt->create(timestamp, sequence++, kAudioSSRC, kOpusPayloadType, sample->bytes, sample->size)) != srs_success) {
+        return srs_error_wrap(err, "rtp packet encode");
+    }
 
-    // v=2,p=0,x=0,cc=0
-    stream->write_1bytes(0x80);
-    // marker payloadtype
-    stream->write_1bytes(kOpusPayloadType);
-    // sequenct
-    stream->write_2bytes(sequence);
-    // timestamp
-    stream->write_4bytes(int32_t(timestamp));
     // TODO: FIXME: Why 960? Need Refactoring?
     timestamp += 960;
-    // ssrc
-    stream->write_4bytes(int32_t(kAudioSSRC));
-
-    stream->write_bytes(sample->bytes, sample->size);
-
-    SrsRtpSharedPacket* rtp_shared_pkt = new SrsRtpSharedPacket();
-    rtp_shared_pkt->create(timestamp, sequence++, kAudioSSRC, kOpusPayloadType, stream->data(), stream->pos());
-    rtp_shared_pkt->set_marker(true);
 
     rtp_packet_vec.push_back(rtp_shared_pkt);
 

trunk/src/app/srs_app_rtc_conn.cpp

@@ -53,6 +53,7 @@ using namespace std;
 #include <srs_http_stack.hpp>
 #include <srs_app_http_api.hpp>
 #include <srs_app_statistic.hpp>
+#include <srs_app_pithy_print.hpp>
 
 static bool is_stun(const uint8_t* data, const int size) 
 {
@@ -520,11 +521,21 @@ srs_error_t SrsRtcSenderThread::cycle()
 
     SrsMessageArray msgs(SRS_PERF_MW_MSGS);
 
+    SrsPithyPrint* pprint = SrsPithyPrint::create_rtc_play();
+    SrsAutoFree(SrsPithyPrint, pprint);
+
     while (true) {
 		if ((err = trd->pull()) != srs_success) {
             return srs_error_wrap(err, "rtc sender thread");
         }
 
+        pprint->elapse();
+
+		if (pprint->can_print()) {
+            // TODO: FIXME:
+            // Print stat like frame/s, packet/s, loss_packets.
+        } 
+
 #ifdef SRS_PERF_QUEUE_COND_WAIT
         if (realtime) {
             // for realtime, min required msgs is 0, send when got one+ msgs.
@@ -577,14 +588,14 @@ void SrsRtcSenderThread::send_and_free_messages(SrsSharedPtrMessage** msgs, int
             SrsRtpSharedPacket* pkt = msg->rtp_packets[i];
 
             if (msg->is_video()) {
-                pkt->set_payload_type(video_payload_type);
+                pkt->modify_rtp_header_payload_type(video_payload_type);
-                pkt->set_ssrc(video_ssrc);
+                pkt->modify_rtp_header_ssrc(video_ssrc);
-                srs_verbose("send video, ssrc=%u, seq=%u, timestamp=%u", video_ssrc, pkt->sequence, pkt->timestamp);
+                srs_verbose("send video, ssrc=%u, seq=%u, timestamp=%u", video_ssrc, pkt->rtp_header.get_sequence(), pkt->rtp_header.get_timestamp());
             }
 
             if (msg->is_audio()) {
-                pkt->set_payload_type(audio_payload_type);
+                pkt->modify_rtp_header_payload_type(audio_payload_type);
-                pkt->set_ssrc(audio_ssrc);
+                pkt->modify_rtp_header_ssrc(audio_ssrc);
             }
 
             int length = pkt->size;
@@ -709,7 +720,10 @@ srs_error_t SrsRtcSession::on_binding_request(SrsUdpMuxSocket* udp_mux_skt, SrsS
 {
     srs_error_t err = srs_success;
 
-    if (stun_req->get_ice_controlled()) {
+    bool strict_check = _srs_config->get_rtc_stun_strict_check(request.vhost);
+    if (strict_check && stun_req->get_ice_controlled()) {
+        // @see: https://tools.ietf.org/html/draft-ietf-ice-rfc5245bis-00#section-6.1.3.1
+        // TODO: Send 487 (Role Conflict) error response.
         return srs_error_new(ERROR_RTC_STUN, "Peer must not in ice-controlled role in ice-lite mode.");
     }
 
@@ -826,7 +840,7 @@ srs_error_t SrsRtcSession::on_rtcp_feedback(char* buf, int nb_buf, SrsUdpMuxSock
             char protected_buf[kRtpPacketSize];
             int nb_protected_buf = resend_pkts[i]->size;
 
-            srs_verbose("resend pkt sequence=%u", resend_pkts[i]->sequence);
+            srs_verbose("resend pkt sequence=%u", resend_pkts[i]->rtp_header.get_sequence());
 
             dtls_session->protect_rtp(protected_buf, resend_pkts[i]->payload, nb_protected_buf);
             udp_mux_skt->sendto(protected_buf, nb_protected_buf, 0);
@@ -1381,8 +1395,8 @@ srs_error_t SrsRtcServer::cycle()
             srs_cond_wait(cond);
         }
 
-        vector<mmsghdr> mhdrs = mmhdrs;
+        vector<mmsghdr> mhdrs;
-        mmhdrs.clear();
+        mmhdrs.swap(mhdrs);
 
         mmsghdr* p = &mhdrs[0];
         for (mmsghdr* end = p + mhdrs.size(); p < end; p += max_sendmmsg) {

trunk/src/app/srs_app_sdp.cpp

@@ -76,11 +76,11 @@ srs_error_t parse_h264_fmtp(const std::string& fmtp, H264SpecificParam& h264_par
         std::vector<std::string> kv = split_str(vec[i], "=");
         if (kv.size() == 2) {
             if (kv[0] == "profile-level-id") {
-                h264_param.profile_level_id = atoi(kv[1].c_str());
+                h264_param.profile_level_id = kv[1];
             } else if (kv[0] == "packetization-mode") {
-                h264_param.packetization_mode = atoi(kv[1].c_str());
+                h264_param.packetization_mode = kv[1];
             } else if (kv[0] == "level-asymmetry-allowed") {
-                h264_param.level_asymmerty_allow = atoi(kv[1].c_str());
+                h264_param.level_asymmerty_allow = kv[1];
             } else {
                 return srs_error_new(ERROR_RTC_SDP_DECODE, "invalid h264 param=%s", kv[0].c_str());
             }

trunk/src/app/srs_app_sdp.hpp

@@ -73,9 +73,9 @@ class SrsSSRCGroup
 
 struct H264SpecificParam
 {
-    int profile_level_id;
+    std::string profile_level_id;
-    int packetization_mode;
+    std::string packetization_mode;
-    int level_asymmerty_allow;
+    std::string level_asymmerty_allow;
 };
 
 extern srs_error_t parse_h264_fmtp(const std::string& fmtp, H264SpecificParam& h264_param);

trunk/src/app/srs_app_source.cpp

@@ -840,13 +840,14 @@ void SrsRtpPacketQueue::clear()
 void SrsRtpPacketQueue::push(std::vector<SrsRtpSharedPacket*>& pkts)
 {
     for (int i = 0; i < (int)pkts.size(); ++i) {
-        insert(pkts[i]->sequence, pkts[i]);
+        insert(pkts[i]->rtp_header.get_sequence(), pkts[i]);
     }
 }
 
 void SrsRtpPacketQueue::insert(const uint16_t& sequence, SrsRtpSharedPacket* pkt)
 {
     pkt_queue.insert(make_pair(sequence, pkt->copy()));
+    // TODO: 3000 is magic number.
     if (pkt_queue.size() >= 3000) {
         srs_freep(pkt_queue.begin()->second);
         pkt_queue.erase(pkt_queue.begin());

trunk/src/kernel/srs_kernel_consts.hpp

@@ -176,6 +176,8 @@
 #define SRS_CONSTS_LOG_STREAM_CASTER "SCS"
 // The nginx exec log id.
 #define SRS_CONSTS_LOG_EXEC "EXE"
+// The rtc.
+#define SRS_CONSTS_LOG_RTC "RTC"
 
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////

trunk/src/kernel/srs_kernel_rtp.cpp

@@ -32,6 +32,117 @@ using namespace std;
 #include <srs_kernel_buffer.hpp>
 #include <srs_kernel_utility.hpp>
 
+
+SrsRtpHeader::SrsRtpHeader()
+{
+    padding          = false;
+    extension        = false;
+    cc               = 0;
+    marker           = false;
+    payload_type     = 0;
+    sequence         = 0;
+    timestamp        = 0;
+    ssrc             = 0;
+    extension_length = 0;
+}
+
+SrsRtpHeader::SrsRtpHeader(const SrsRtpHeader& rhs)
+{
+    operator=(rhs);
+}
+
+SrsRtpHeader& SrsRtpHeader::operator=(const SrsRtpHeader& rhs)
+{
+    padding          = rhs.padding;
+    extension        = rhs.extension;
+    cc               = rhs.cc;
+    marker           = rhs.marker;
+    payload_type     = rhs.payload_type;
+    sequence         = rhs.sequence;
+    timestamp        = rhs.timestamp;
+    ssrc             = rhs.ssrc;
+    for (size_t i = 0; i < cc; ++i) {
+        csrc[i] = rhs.csrc[i];
+    }
+    extension_length = rhs.extension_length;
+
+    return *this;
+}
+
+SrsRtpHeader::~SrsRtpHeader()
+{
+}
+
+srs_error_t SrsRtpHeader::decode(SrsBuffer* stream)
+{
+    srs_error_t err = srs_success;
+
+    // TODO:
+
+    return err;
+}
+
+srs_error_t SrsRtpHeader::encode(SrsBuffer* stream)
+{
+    srs_error_t err = srs_success;
+
+    uint8_t first = 0x80 | cc;
+    if (padding) {
+        first |= 0x40;
+    }
+    if (extension) {
+        first |= 0x10;
+    }
+    stream->write_1bytes(first);
+    uint8_t second = payload_type;
+    if (marker) {
+        payload_type |= kRtpMarker;
+    }
+    stream->write_1bytes(second);
+    stream->write_2bytes(sequence);
+    stream->write_4bytes(timestamp);
+    stream->write_4bytes(ssrc);
+    for (size_t i = 0; i < cc; ++i) {
+        stream->write_4bytes(csrc[i]);
+    }
+
+    // TODO: Write exteinsion field.
+    if (extension) {
+    }
+
+    return err;
+}
+
+size_t SrsRtpHeader::header_size()
+{
+    return kRtpHeaderFixedSize + cc * 4 + (extension ? (extension_length + 1) * 4 : 0);
+}
+
+void SrsRtpHeader::set_marker(bool marker)
+{
+    this->marker = marker;
+}
+
+void SrsRtpHeader::set_payload_type(uint8_t payload_type)
+{
+    this->payload_type = payload_type;
+}
+
+void SrsRtpHeader::set_sequence(uint16_t sequence)
+{
+    this->sequence = sequence;
+}
+
+void SrsRtpHeader::set_timestamp(int64_t timestamp)
+{
+    this->timestamp = timestamp;
+}
+
+void SrsRtpHeader::set_ssrc(uint32_t ssrc)
+{
+    this->ssrc = ssrc;
+}
+
 SrsRtpSharedPacket::SrsRtpSharedPacketPayload::SrsRtpSharedPacketPayload()
 {
     payload = NULL;
@@ -50,11 +161,6 @@ SrsRtpSharedPacket::SrsRtpSharedPacket()
 
     payload = NULL;
     size = 0;
-
-    timestamp = -1;
-    sequence = 0;
-    ssrc = 0;
-    payload_type = 0;
 }
 
 SrsRtpSharedPacket::~SrsRtpSharedPacket()
@@ -68,27 +174,38 @@ SrsRtpSharedPacket::~SrsRtpSharedPacket()
     }
 }
 
-srs_error_t SrsRtpSharedPacket::create(int64_t t, uint16_t seq, uint32_t sc, uint16_t pt, char* p, int s)
+srs_error_t SrsRtpSharedPacket::create(int64_t timestamp, uint16_t sequence, uint32_t ssrc, uint16_t payload_type, char* p, int s)
 {
     srs_error_t err = srs_success;
 
-    if (size < 0) {
+    if (s < 0) {
-        return srs_error_new(ERROR_RTP_PACKET_CREATE, "create packet size=%d", size);
+        return srs_error_new(ERROR_RTP_PACKET_CREATE, "create packet size=%d", s);
     }   
 
     srs_assert(!payload_ptr);
 
-    timestamp = t;
+    rtp_header.set_timestamp(timestamp);
-    sequence = seq;
+    rtp_header.set_sequence(sequence);
-    ssrc = sc;
+    rtp_header.set_ssrc(ssrc);
-    payload_type = pt;
+    rtp_header.set_payload_type(payload_type);
 
+    // TODO: rtp header padding.
+    size_t buffer_size = rtp_header.header_size() + s;
+    
+    char* buffer = new char[buffer_size];
+    SrsBuffer stream(buffer, buffer_size);
+    if ((err = rtp_header.encode(&stream)) != srs_success) {
+        srs_freepa(buffer);
+        return srs_error_wrap(err, "rtp header encode");
+    }
+
+    stream.write_bytes(p, s);
     payload_ptr = new SrsRtpSharedPacketPayload();
-    payload_ptr->payload = p;
+    payload_ptr->payload = buffer;
-    payload_ptr->size = s;
+    payload_ptr->size = buffer_size;
 
-    payload = payload_ptr->payload;
+    this->payload = payload_ptr->payload;
-    size = payload_ptr->size;
+    this->size = payload_ptr->size;
 
     return err;
 }
@@ -100,56 +217,57 @@ SrsRtpSharedPacket* SrsRtpSharedPacket::copy()
     copy->payload_ptr = payload_ptr;
     payload_ptr->shared_count++;
 
+    copy->rtp_header = rtp_header;
+
     copy->payload = payload;
     copy->size = size;
 
-    copy->timestamp = timestamp;
-    copy->sequence = sequence;
-    copy->ssrc = ssrc;
-    copy->payload_type = payload_type;
-
     return copy;
 }
 
-srs_error_t SrsRtpSharedPacket::set_marker(bool marker)
+srs_error_t SrsRtpSharedPacket::modify_rtp_header_marker(bool marker)
 {
     srs_error_t err = srs_success;
-    if (payload_ptr == NULL || payload_ptr->payload == NULL || payload_ptr->size < 1) {
+    if (payload_ptr == NULL || payload_ptr->payload == NULL || payload_ptr->size < kRtpHeaderFixedSize) {
         return srs_error_new(ERROR_RTC_RTP_MUXER, "rtp payload incorrect");
     }
 
+    rtp_header.set_marker(marker);
     if (marker) {
-        payload_ptr->payload[1] |= kMarker;
+        payload_ptr->payload[1] |= kRtpMarker;
     } else {
-        payload_ptr->payload[1] &= (~kMarker);
+        payload_ptr->payload[1] &= (~kRtpMarker);
     }
 
     return err;
 }
 
-srs_error_t SrsRtpSharedPacket::set_ssrc(uint32_t ssrc)
+srs_error_t SrsRtpSharedPacket::modify_rtp_header_ssrc(uint32_t ssrc)
 {
     srs_error_t err = srs_success;
 
-    if (payload_ptr == NULL || payload_ptr->payload == NULL || payload_ptr->size < 12) {
+    if (payload_ptr == NULL || payload_ptr->payload == NULL || payload_ptr->size < kRtpHeaderFixedSize) {
         return srs_error_new(ERROR_RTC_RTP_MUXER, "rtp payload incorrect");
     }
 
+    rtp_header.set_ssrc(ssrc);
+
     SrsBuffer stream(payload_ptr->payload + 8, 4);
     stream.write_4bytes(ssrc);
 
     return err;
 }
 
-srs_error_t SrsRtpSharedPacket::set_payload_type(uint8_t pt)
+srs_error_t SrsRtpSharedPacket::modify_rtp_header_payload_type(uint8_t payload_type)
 {
     srs_error_t err = srs_success;
 
-    if (payload_ptr == NULL || payload_ptr->payload == NULL || payload_ptr->size < 2) {
+    if (payload_ptr == NULL || payload_ptr->payload == NULL || payload_ptr->size < kRtpHeaderFixedSize) {
         return srs_error_new(ERROR_RTC_RTP_MUXER, "rtp payload incorrect");
     }
 
-    payload_ptr->payload[1] = (payload_ptr->payload[1] & 0x80) | pt;
+    rtp_header.set_payload_type(payload_type);
+    payload_ptr->payload[1] = (payload_ptr->payload[1] & 0x80) | payload_type;
 
     return err;
 }

trunk/src/kernel/srs_kernel_rtp.hpp

@@ -28,42 +28,79 @@
 
 #include <string>
 
-const uint8_t kMarker = 0x80;
+const int kRtpHeaderFixedSize = 12;
+const uint8_t kRtpMarker = 0x80;
+
+class SrsBuffer;
+
+class SrsRtpHeader
+{
+private:
+    bool padding;
+    bool extension;
+    uint8_t cc;
+    bool marker;
+    uint8_t payload_type;
+    uint16_t sequence;
+    int64_t timestamp;
+    uint32_t ssrc;
+    uint32_t csrc[15];
+    uint16_t extension_length;
+    // TODO:extension field.
+public:
+    SrsRtpHeader();
+    virtual ~SrsRtpHeader();
+    SrsRtpHeader(const SrsRtpHeader& rhs);
+    SrsRtpHeader& operator=(const SrsRtpHeader& rhs);
+public:
+    srs_error_t decode(SrsBuffer* stream);
+    srs_error_t encode(SrsBuffer* stream);
+public:
+    size_t header_size();
+public:
+    void set_marker(bool marker);
+    bool get_marker() const { return marker; }
+    void set_payload_type(uint8_t payload_type);
+    uint8_t get_payload_type() const { return payload_type; }
+    void set_sequence(uint16_t sequence);
+    uint16_t get_sequence() const  { return sequence; }
+    void set_timestamp(int64_t timestamp);
+    int64_t get_timestamp() const { return timestamp; }
+    void set_ssrc(uint32_t ssrc);
+    uint32_t get_ssrc() const { return ssrc; }
+};
 
 class SrsRtpSharedPacket
 {
 private:
-     class SrsRtpSharedPacketPayload 
+    class SrsRtpSharedPacketPayload 
-     {   
+    {   
-     public:
+    public:
-         char* payload;
+        // Rtp packet buffer, include rtp header and payload.
-         int size;
+        char* payload;
-         int shared_count;
+        int size;
-     public:
+        int shared_count;
-         SrsRtpSharedPacketPayload();
+    public:
-         virtual ~SrsRtpSharedPacketPayload();
+        SrsRtpSharedPacketPayload();
-     };  
+        virtual ~SrsRtpSharedPacketPayload();
+    };  
 private:
-     SrsRtpSharedPacketPayload* payload_ptr;
+    SrsRtpSharedPacketPayload* payload_ptr;
 public:
-     char* payload;
+    SrsRtpHeader rtp_header;
-     int size;
+    char* payload;
-public:
+    int size;
-     int64_t timestamp;
-     uint16_t sequence;
-     uint32_t ssrc;
-     uint16_t payload_type;
 public:
     SrsRtpSharedPacket();
     virtual ~SrsRtpSharedPacket();
 public:
-    srs_error_t create(int64_t t, uint16_t seq, uint32_t sc, uint16_t pt, char* p, int s);
+    srs_error_t create(int64_t timestamp, uint16_t sequence, uint32_t ssrc, uint16_t payload_type, char* payload, int size);
     SrsRtpSharedPacket* copy();
-// interface to modify rtp header
+// Interface to modify rtp header 
 public:
-    srs_error_t set_marker(bool marker);
+    srs_error_t modify_rtp_header_marker(bool marker);
-    srs_error_t set_ssrc(uint32_t ssrc);
+    srs_error_t modify_rtp_header_ssrc(uint32_t ssrc);
-    srs_error_t set_payload_type(uint8_t pt);
+    srs_error_t modify_rtp_header_payload_type(uint8_t payload_type);
 };
 
 #endif