diff --git a/trunk/conf/full.conf b/trunk/conf/full.conf index a4a901ab9..0f45df751 100644 --- a/trunk/conf/full.conf +++ b/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. diff --git a/trunk/src/app/srs_app_config.cpp b/trunk/src/app/srs_app_config.cpp index ecb2b4f42..6868adfed 100644 --- a/trunk/src/app/srs_app_config.cpp +++ b/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); diff --git a/trunk/src/app/srs_app_config.hpp b/trunk/src/app/srs_app_config.hpp index bf5fa6dc7..3f01c0031 100644 --- a/trunk/src/app/srs_app_config.hpp +++ b/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: diff --git a/trunk/src/app/srs_app_http_api.cpp b/trunk/src/app/srs_app_http_api.cpp index 096cec496..050c40a09 100644 --- a/trunk/src/app/srs_app_http_api.cpp +++ b/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 backup_payloads; std::vector payloads = remote_media_desc.find_media_with_encoding_name("H264"); for (std::vector::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"); } } diff --git a/trunk/src/app/srs_app_pithy_print.cpp b/trunk/src/app/srs_app_pithy_print.cpp index 9aacf3bfe..cef07f1de 100644 --- a/trunk/src/app/srs_app_pithy_print.cpp +++ b/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(); diff --git a/trunk/src/app/srs_app_pithy_print.hpp b/trunk/src/app/srs_app_pithy_print.hpp index b2494b926..c3b9f1219 100644 --- a/trunk/src/app/srs_app_pithy_print.hpp +++ b/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. diff --git a/trunk/src/app/srs_app_rtc.cpp b/trunk/src/app/srs_app_rtc.cpp index 4cfbae405..8424216ce 100644 --- a/trunk/src/app/srs_app_rtc.cpp +++ b/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]; - SrsBuffer* stream = new SrsBuffer(buf, kRtpPacketSize); - SrsAutoFree(SrsBuffer, stream); + SrsRtpSharedPacket* rtp_shared_pkt = new SrsRtpSharedPacket(); + rtp_shared_pkt->rtp_header.set_marker(true); + 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); diff --git a/trunk/src/app/srs_app_rtc_conn.cpp b/trunk/src/app/srs_app_rtc_conn.cpp index bc1cf3b30..96a4fd0d8 100644 --- a/trunk/src/app/srs_app_rtc_conn.cpp +++ b/trunk/src/app/srs_app_rtc_conn.cpp @@ -53,6 +53,7 @@ using namespace std; #include #include #include +#include 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->set_ssrc(video_ssrc); - srs_verbose("send video, ssrc=%u, seq=%u, timestamp=%u", video_ssrc, pkt->sequence, pkt->timestamp); + pkt->modify_rtp_header_payload_type(video_payload_type); + pkt->modify_rtp_header_ssrc(video_ssrc); + 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->set_ssrc(audio_ssrc); + pkt->modify_rtp_header_payload_type(audio_payload_type); + 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 mhdrs = mmhdrs; - mmhdrs.clear(); + vector mhdrs; + mmhdrs.swap(mhdrs); mmsghdr* p = &mhdrs[0]; for (mmsghdr* end = p + mhdrs.size(); p < end; p += max_sendmmsg) { diff --git a/trunk/src/app/srs_app_sdp.cpp b/trunk/src/app/srs_app_sdp.cpp index f9ec31b13..f5f4ee47f 100644 --- a/trunk/src/app/srs_app_sdp.cpp +++ b/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 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()); } diff --git a/trunk/src/app/srs_app_sdp.hpp b/trunk/src/app/srs_app_sdp.hpp index 839f9cb5c..c0fb95321 100644 --- a/trunk/src/app/srs_app_sdp.hpp +++ b/trunk/src/app/srs_app_sdp.hpp @@ -73,9 +73,9 @@ class SrsSSRCGroup struct H264SpecificParam { - int profile_level_id; - int packetization_mode; - int level_asymmerty_allow; + std::string profile_level_id; + std::string packetization_mode; + std::string level_asymmerty_allow; }; extern srs_error_t parse_h264_fmtp(const std::string& fmtp, H264SpecificParam& h264_param); diff --git a/trunk/src/app/srs_app_source.cpp b/trunk/src/app/srs_app_source.cpp index 94d24e250..cb7d1b505 100755 --- a/trunk/src/app/srs_app_source.cpp +++ b/trunk/src/app/srs_app_source.cpp @@ -840,13 +840,14 @@ void SrsRtpPacketQueue::clear() void SrsRtpPacketQueue::push(std::vector& 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()); diff --git a/trunk/src/kernel/srs_kernel_consts.hpp b/trunk/src/kernel/srs_kernel_consts.hpp index 208765ae7..dc6449045 100644 --- a/trunk/src/kernel/srs_kernel_consts.hpp +++ b/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" /////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////// diff --git a/trunk/src/kernel/srs_kernel_rtp.cpp b/trunk/src/kernel/srs_kernel_rtp.cpp index d43e19aea..59ad7ca93 100644 --- a/trunk/src/kernel/srs_kernel_rtp.cpp +++ b/trunk/src/kernel/srs_kernel_rtp.cpp @@ -32,6 +32,117 @@ using namespace std; #include #include + +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) { - return srs_error_new(ERROR_RTP_PACKET_CREATE, "create packet size=%d", size); + if (s < 0) { + return srs_error_new(ERROR_RTP_PACKET_CREATE, "create packet size=%d", s); } srs_assert(!payload_ptr); - timestamp = t; - sequence = seq; - ssrc = sc; - payload_type = pt; + rtp_header.set_timestamp(timestamp); + rtp_header.set_sequence(sequence); + rtp_header.set_ssrc(ssrc); + 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->size = s; + payload_ptr->payload = buffer; + payload_ptr->size = buffer_size; - payload = payload_ptr->payload; - size = payload_ptr->size; + this->payload = payload_ptr->payload; + 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; } diff --git a/trunk/src/kernel/srs_kernel_rtp.hpp b/trunk/src/kernel/srs_kernel_rtp.hpp index f5720af49..396cb2687 100644 --- a/trunk/src/kernel/srs_kernel_rtp.hpp +++ b/trunk/src/kernel/srs_kernel_rtp.hpp @@ -28,42 +28,79 @@ #include -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 - { - public: - char* payload; - int size; - int shared_count; - public: - SrsRtpSharedPacketPayload(); - virtual ~SrsRtpSharedPacketPayload(); - }; + class SrsRtpSharedPacketPayload + { + public: + // Rtp packet buffer, include rtp header and payload. + char* payload; + int size; + int shared_count; + public: + SrsRtpSharedPacketPayload(); + virtual ~SrsRtpSharedPacketPayload(); + }; private: - SrsRtpSharedPacketPayload* payload_ptr; + SrsRtpSharedPacketPayload* payload_ptr; public: - char* payload; - int size; -public: - int64_t timestamp; - uint16_t sequence; - uint32_t ssrc; - uint16_t payload_type; + SrsRtpHeader rtp_header; + char* payload; + int size; 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 set_ssrc(uint32_t ssrc); - srs_error_t set_payload_type(uint8_t pt); + srs_error_t modify_rtp_header_marker(bool marker); + srs_error_t modify_rtp_header_ssrc(uint32_t ssrc); + srs_error_t modify_rtp_header_payload_type(uint8_t payload_type); }; #endif