external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-03-09 15:49:59 +00:00
Code Issues Releases Wiki Activity

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

Browse source
This commit is contained in:
winlin 2020-04-09 08:17:21 +08:00
commit d59ec158f9
14 changed files with 307 additions and 137 deletions
Download patch file Download diff file Expand all files Collapse all files

3
trunk/conf/full.conf
View file

@ -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.

20
trunk/src/app/srs_app_config.cpp
View file

@ -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);

1
trunk/src/app/srs_app_config.hpp
View file

@ -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:

20
trunk/src/app/srs_app_http_api.cpp
View file

@ -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");
}
}

7
trunk/src/app/srs_app_pithy_print.cpp
View file

@ -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();

1
trunk/src/app/srs_app_pithy_print.hpp
View file

@ -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.

80
trunk/src/app/srs_app_rtc.cpp
View file

@ -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);

32
trunk/src/app/srs_app_rtc_conn.cpp
View file

@ -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->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<mmsghdr> mhdrs = mmhdrs;
mmhdrs.clear();
vector<mmsghdr> mhdrs;
mmhdrs.swap(mhdrs);
mmsghdr* p = &mhdrs[0];
for (mmsghdr* end = p + mhdrs.size(); p < end; p += max_sendmmsg) {

6
trunk/src/app/srs_app_sdp.cpp
View file

@ -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());
}

6
trunk/src/app/srs_app_sdp.hpp
View file

@ -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);

3
trunk/src/app/srs_app_source.cpp
View file

@ -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());

2
trunk/src/kernel/srs_kernel_consts.hpp
View file

@ -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"
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////

178
trunk/src/kernel/srs_kernel_rtp.cpp
View file

@ -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) {
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;
}

59
trunk/src/kernel/srs_kernel_rtp.hpp
View file

@ -28,7 +28,47 @@
#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
{
@ -36,6 +76,7 @@ private:
class SrsRtpSharedPacketPayload
{
public:
// Rtp packet buffer, include rtp header and payload.
char* payload;
int size;
int shared_count;
@ -46,24 +87,20 @@ private:
private:
SrsRtpSharedPacketPayload* payload_ptr;
public:
SrsRtpHeader rtp_header;
char* payload;
int size;
public:
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 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