external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-02-15 04:42:04 +00:00
Code Issues Releases Wiki Activity

merge feature/rtc, fix conflict

Browse source
This commit is contained in:
HuyaJohn 2020-03-18 16:34:15 -07:00
commit 94e4f4539d
4 changed files with 83 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
trunk/research/players/rtc_player.html
View file

@ -45,7 +45,7 @@
</div>
<label></label>
<video id="rtc_media_player" autoplay controls></video>
<video id="rtc_media_player" controls autoplay></video>
<footer>
<p></p>
@ -53,20 +53,21 @@
</footer>
</div>
<script type="text/javascript">
var pc = null; // Global handler to do cleanup when replaying.
$(function(){
$('#rtc_media_player').hide();
var query = parse_query_string();
srs_init_rtc("#txt_url", query);
$("#btn_play").click(function(){
var startPlay = function() {
$('#rtc_media_player').show();
var urlObject = parse_rtmp_url($("#txt_url").val());
var schame = window.location.protocol;
var pc = new RTCPeerConnection(null);
// Close PC when user replay.
if (pc) {
pc.close();
}
pc = new RTCPeerConnection(null);
pc.onaddstream = function (event) {
var player = document.getElementById('rtc_media_player');
player.srcObject = event.stream;
$('#rtc_media_player').prop('srcObject', event.stream);
};
new Promise(function(resolve, reject) {
pc.createOffer(function(offer){
@ -119,7 +120,18 @@
}).catch(function(reason) {
throw reason;
});
});
};
$('#rtc_media_player').hide();
var query = parse_query_string();
srs_init_rtc("#txt_url", query);
$("#btn_play").click(startPlay);
if (query.autostart === 'true') {
// For autostart, we should mute it, see https://www.jianshu.com/p/c3c6944eed5a
$('#rtc_media_player').prop('muted', true);
startPlay();
}
});
</script>
</body>

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

@ -137,7 +137,7 @@ srs_error_t SrsSdp::decode(const string& sdp_str)
srs_error_t err = srs_success;
if (sdp_str.size() < 2 || sdp_str[0] != 'v' || sdp_str[1] != '=') {
return srs_error_wrap(err, "invalid sdp_str");
return srs_error_new(ERROR_RTC_SDP_DECODE, "invalid sdp_str");
}
string line;
@ -146,7 +146,7 @@ srs_error_t SrsSdp::decode(const string& sdp_str)
srs_verbose("line=%s", line.c_str());
if (line.size() < 2 || line[1] != '=') {
return srs_error_wrap(err, "invalid sdp line=%s", line.c_str());
return srs_error_new(ERROR_RTC_SDP_DECODE, "invalid sdp line=%s", line.c_str());
}
switch (line[0]) {
@ -167,7 +167,7 @@ srs_error_t SrsSdp::decode(const string& sdp_str)
}
case 'a' :{
if ((err = parse_attr(line)) != srs_success) {
return srs_error_wrap(err, "decode sdp line=%s failed", line.c_str());
return srs_error_new(ERROR_RTC_SDP_DECODE, "decode sdp line=%s failed", line.c_str());
}
break;
}
@ -397,7 +397,6 @@ srs_error_t SrsDtlsSession::on_dtls_handshake_done(SrsUdpMuxSocket* udp_mux_skt)
handshake_done = true;
if ((err = srtp_initialize()) != srs_success) {
srs_error("srtp init failed, err=%s", srs_error_desc(err).c_str());
return srs_error_wrap(err, "srtp init failed");
}
@ -450,7 +449,7 @@ srs_error_t SrsDtlsSession::srtp_initialize()
unsigned char material[SRTP_MASTER_KEY_LEN * 2] = {0}; // client(SRTP_MASTER_KEY_KEY_LEN + SRTP_MASTER_KEY_SALT_LEN) + server
static const string dtls_srtp_lable = "EXTRACTOR-dtls_srtp";
if (! SSL_export_keying_material(dtls, material, sizeof(material), dtls_srtp_lable.c_str(), dtls_srtp_lable.size(), NULL, 0, 0)) {
return srs_error_wrap(err, "SSL_export_keying_material failed");
return srs_error_new(ERROR_RTC_SRTP_INIT, "SSL_export_keying_material failed");
}
size_t offset = 0;
@ -501,7 +500,7 @@ srs_error_t SrsDtlsSession::srtp_send_init()
if (srtp_create(&srtp_send, &policy) != 0) {
srs_freepa(key);
return srs_error_wrap(err, "srtp_create failed");
return srs_error_new(ERROR_RTC_SRTP_INIT, "srtp_create failed");
}
srs_freepa(key);
@ -533,7 +532,7 @@ srs_error_t SrsDtlsSession::srtp_recv_init()
if (srtp_create(&srtp_recv, &policy) != 0) {
srs_freepa(key);
return srs_error_wrap(err, "srtp_create failed");
return srs_error_new(ERROR_RTC_SRTP_INIT, "srtp_create failed");
}
srs_freepa(key);
@ -548,13 +547,13 @@ srs_error_t SrsDtlsSession::protect_rtp(char* out_buf, const char* in_buf, int&
if (srtp_send) {
memcpy(out_buf, in_buf, nb_out_buf);
if (srtp_protect(srtp_send, out_buf, &nb_out_buf) != 0) {
return srs_error_wrap(err, "rtp protect failed");
return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtp protect failed");
}
return err;
}
return srs_error_wrap(err, "rtp protect failed");
return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtp protect failed");
}
srs_error_t SrsDtlsSession::unprotect_rtp(char* out_buf, const char* in_buf, int& nb_out_buf)
@ -564,13 +563,13 @@ srs_error_t SrsDtlsSession::unprotect_rtp(char* out_buf, const char* in_buf, int
if (srtp_recv) {
memcpy(out_buf, in_buf, nb_out_buf);
if (srtp_unprotect(srtp_recv, out_buf, &nb_out_buf) != 0) {
return srs_error_wrap(err, "rtp unprotect failed");
return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "rtp unprotect failed");
}
return err;
}
return srs_error_wrap(err, "rtp unprotect failed");
return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "rtp unprotect failed");
}
srs_error_t SrsDtlsSession::protect_rtcp(char* out_buf, const char* in_buf, int& nb_out_buf)
@ -580,13 +579,13 @@ srs_error_t SrsDtlsSession::protect_rtcp(char* out_buf, const char* in_buf, int&
if (srtp_send) {
memcpy(out_buf, in_buf, nb_out_buf);
if (srtp_protect_rtcp(srtp_send, out_buf, &nb_out_buf) != 0) {
return srs_error_wrap(err, "rtcp protect failed");
return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtcp protect failed");
}
return err;
}
return srs_error_wrap(err, "rtcp protect failed");
return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtcp protect failed");
}
srs_error_t SrsDtlsSession::unprotect_rtcp(char* out_buf, const char* in_buf, int& nb_out_buf)
@ -596,13 +595,13 @@ srs_error_t SrsDtlsSession::unprotect_rtcp(char* out_buf, const char* in_buf, in
if (srtp_recv) {
memcpy(out_buf, in_buf, nb_out_buf);
if (srtp_unprotect_rtcp(srtp_recv, out_buf, &nb_out_buf) != 0) {
return srs_error_wrap(err, "rtcp unprotect failed");
return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "rtcp unprotect failed");
}
return err;
}
return srs_error_wrap(err, "rtcp unprotect failed");
return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "rtcp unprotect failed");
}
SrsRtcSenderThread::SrsRtcSenderThread(SrsRtcSession* s, SrsUdpMuxSocket* u, int parent_cid)
@ -702,17 +701,30 @@ srs_error_t SrsRtcSenderThread::cycle()
void SrsRtcSenderThread::send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, SrsUdpMuxSocket* udp_mux_skt)
{
srs_error_t err = srs_success;
for (int i = 0; i < nb_msgs; i++) {
SrsSharedPtrMessage* msg = msgs[i];
for (int i = 0; i < (int)msg->rtp_packets.size(); ++i) {
if (rtc_session->dtls_session) {
char protected_buf[kRtpPacketSize];
int nb_protected_buf = msg->rtp_packets[i]->size;
if (!rtc_session->dtls_session) {
continue;
}
rtc_session->dtls_session->protect_rtp(protected_buf, msg->rtp_packets[i]->payload, nb_protected_buf);
// TODO: use sendmmsg to send multi packet one system call
udp_mux_skt->sendto(protected_buf, nb_protected_buf, 0);
SrsRtpSharedPacket* pkt = msg->rtp_packets[i];
int length = pkt->size;
char buf[kRtpPacketSize];
if ((err = rtc_session->dtls_session->protect_rtp(buf, pkt->payload, length)) != srs_success) {
srs_warn("srtp err %s", srs_error_desc(err).c_str());
srs_freep(err);
continue;
}
// TODO: use sendmmsg to send multi packet one system call
if ((err = udp_mux_skt->sendto(buf, length, 0)) != srs_success) {
srs_warn("send err %s", srs_error_desc(err).c_str());
srs_freep(err);
}
}
@ -826,7 +838,7 @@ srs_error_t SrsRtcSession::on_rtcp_feedback(char* buf, int nb_buf, SrsUdpMuxSock
srs_error_t err = srs_success;
if (nb_buf < 12) {
return srs_error_wrap(err, "invalid rtp feedback packet, nb_buf=%d", nb_buf);
return srs_error_new(ERROR_RTC_RTCP_CHECK, "invalid rtp feedback packet, nb_buf=%d", nb_buf);
}
SrsBuffer* stream = new SrsBuffer(buf, nb_buf);
@ -873,7 +885,7 @@ srs_error_t SrsRtcSession::on_rtcp_feedback(char* buf, int nb_buf, SrsUdpMuxSock
return srs_error_wrap(err, "check");
}
if (! source) {
return srs_error_wrap(err, "can not found source");
return srs_error_new(ERROR_RTC_SOURCE_CHECK, "can not found source");
}
vector<SrsRtpSharedPacket*> resend_pkts;
@ -918,7 +930,7 @@ srs_error_t SrsRtcSession::on_rtcp_ps_feedback(char* buf, int nb_buf, SrsUdpMuxS
srs_error_t err = srs_success;
if (nb_buf < 12) {
return srs_error_wrap(err, "invalid rtp feedback packet, nb_buf=%d", nb_buf);
return srs_error_new(ERROR_RTC_RTCP_CHECK, "invalid rtp feedback packet, nb_buf=%d", nb_buf);
}
SrsBuffer* stream = new SrsBuffer(buf, nb_buf);
@ -953,7 +965,7 @@ srs_error_t SrsRtcSession::on_rtcp_ps_feedback(char* buf, int nb_buf, SrsUdpMuxS
break;
}
default: {
return srs_error_wrap(err, "unknown payload specific feedback=%u", fmt);
return srs_error_new(ERROR_RTC_RTCP, "unknown payload specific feedback=%u", fmt);
}
}
@ -965,7 +977,7 @@ srs_error_t SrsRtcSession::on_rtcp_receiver_report(char* buf, int nb_buf, SrsUdp
srs_error_t err = srs_success;
if (nb_buf < 8) {
return srs_error_wrap(err, "invalid rtp receiver report packet, nb_buf=%d", nb_buf);
return srs_error_new(ERROR_RTC_RTCP_CHECK, "invalid rtp receiver report packet, nb_buf=%d", nb_buf);
}
SrsBuffer* stream = new SrsBuffer(buf, nb_buf);
@ -1009,7 +1021,7 @@ block +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
/*uint32_t ssrc_of_sender = */stream->read_4bytes();
if (((length + 1) * 4) != (rc * 24 + 8)) {
return srs_error_wrap(err, "invalid rtcp receiver packet, length=%u, rc=%u", length, rc);
return srs_error_new(ERROR_RTC_RTCP_CHECK, "invalid rtcp receiver packet, length=%u, rc=%u", length, rc);
}
for (int i = 0; i < rc; ++i) {
@ -1066,55 +1078,6 @@ srs_error_t SrsRtcSession::on_dtls(SrsUdpMuxSocket* udp_mux_skt)
return dtls_session->on_dtls(udp_mux_skt);
}
srs_error_t SrsRtcSession::on_rtp(SrsUdpMuxSocket* udp_mux_skt)
{
srs_error_t err = srs_success;
if (dtls_session == NULL) {
return srs_error_new(ERROR_RTC_RTP, "recv unexpect rtp packet before dtls done");
}
char unprotected_buf[1460];
int nb_unprotected_buf = udp_mux_skt->size();
if ((err = dtls_session->unprotect_rtp(unprotected_buf, udp_mux_skt->data(), nb_unprotected_buf)) != srs_success) {
return srs_error_wrap(err, "rtp unprotect failed");
}
// FIXME: use SrsRtpPacket
SrsBuffer* stream = new SrsBuffer(unprotected_buf, nb_unprotected_buf);
SrsAutoFree(SrsBuffer, stream);
uint8_t first = stream->read_1bytes();
uint8_t second = stream->read_1bytes();
bool padding = (first & 0x20);
bool ext = (first & 0x10);
uint8_t cc = (first & 0x0F);
bool marker = (second & 0x80);
uint16_t sequence = stream->read_2bytes();
uint32_t timestamp = stream->read_4bytes();
uint32_t ssrc = stream->read_4bytes();
srs_verbose("sequence=%u, timestamp=%u, ssrc=%u, padding=%d, ext=%d, cc=%u, marker=%d",
sequence, timestamp, ssrc, padding, ext, cc, marker);
for (uint8_t i = 0; i < cc; ++i) {
/*uint32_t csrc = */stream->read_4bytes();
}
if (ext) {
uint16_t extern_profile = stream->read_2bytes();
uint16_t extern_length = stream->read_2bytes();
(void)extern_profile; (void)extern_length;
srs_verbose("extern_profile=%u, extern_length=%u", extern_profile, extern_length);
stream->read_string(extern_length * 4);
}
return err;
}
srs_error_t SrsRtcSession::on_rtcp(SrsUdpMuxSocket* udp_mux_skt)
{
srs_error_t err = srs_success;
@ -1169,7 +1132,7 @@ srs_error_t SrsRtcSession::on_rtcp(SrsUdpMuxSocket* udp_mux_skt)
break;
}
default:{
return srs_error_wrap(err, "unknown rtcp type=%u", payload_type);
return srs_error_new(ERROR_RTC_RTCP_CHECK, "unknown rtcp type=%u", payload_type);
break;
}
}
@ -1357,7 +1320,9 @@ srs_error_t SrsRtcServer::on_rtp_or_rtcp(SrsUdpMuxSocket* udp_mux_skt)
if (is_rtcp(reinterpret_cast<const uint8_t*>(udp_mux_skt->data()), udp_mux_skt->size())) {
err = rtc_session->on_rtcp(udp_mux_skt);
} else {
err = rtc_session->on_rtp(udp_mux_skt);
// We disable it because no RTP for player.
// see https://github.com/ossrs/srs/blob/018577e685a07d9de7a47354e7a9c5f77f5f4202/trunk/src/app/srs_app_rtc_conn.cpp#L1081
// err = rtc_session->on_rtp(udp_mux_skt);
}
return err;
@ -1452,7 +1417,6 @@ srs_error_t SrsRtcTimerThread::cycle()
while (true) {
if ((err = trd->pull()) != srs_success) {
srs_trace("rtc_timer cycle failed");
return srs_error_wrap(err, "rtc timer thread");
}

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

@ -221,7 +221,6 @@ public:
public:
srs_error_t on_stun(SrsUdpMuxSocket* udp_mux_skt, SrsStunPacket* stun_req);
srs_error_t on_dtls(SrsUdpMuxSocket* udp_mux_skt);
srs_error_t on_rtp(SrsUdpMuxSocket* udp_mux_skt);
srs_error_t on_rtcp(SrsUdpMuxSocket* udp_mux_skt);
public:
srs_error_t send_client_hello(SrsUdpMuxSocket* udp_mux_skt);

30
trunk/src/kernel/srs_kernel_error.hpp
View file

@ -328,18 +328,24 @@
///////////////////////////////////////////////////////
// RTC protocol error.
///////////////////////////////////////////////////////
#define ERROR_RTC_PORT 4041
#define ERROR_RTP_PACKET_CREATE 4042
#define ERROR_OpenSslCreateSSL 4043
#define ERROR_OpenSslBIOReset 4044
#define ERROR_OpenSslBIOWrite 4045
#define ERROR_OpenSslBIONew 4046
#define ERROR_RTC_RTP 4047
#define ERROR_RTC_RTCP 4048
#define ERROR_RTC_STUN 4049
#define ERROR_RTC_DTLS 4050
#define ERROR_RTC_UDP 4051
#define ERROR_RTC_RTP_MUXER 4052
#define ERROR_RTC_PORT 5000
#define ERROR_RTP_PACKET_CREATE 5001
#define ERROR_OpenSslCreateSSL 5002
#define ERROR_OpenSslBIOReset 5003
#define ERROR_OpenSslBIOWrite 5004
#define ERROR_OpenSslBIONew 5005
#define ERROR_RTC_RTP 5006
#define ERROR_RTC_RTCP 5007
#define ERROR_RTC_STUN 5008
#define ERROR_RTC_DTLS 5009
#define ERROR_RTC_UDP 5010
#define ERROR_RTC_RTP_MUXER 5011
#define ERROR_RTC_SDP_DECODE 5012
#define ERROR_RTC_SRTP_INIT 5013
#define ERROR_RTC_SRTP_PROTECT 5014
#define ERROR_RTC_SRTP_UNPROTECT 5015
#define ERROR_RTC_RTCP_CHECK 5016
#define ERROR_RTC_SOURCE_CHECK 5017
///////////////////////////////////////////////////////
// HTTP API error.