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

RTC: Remove Object Cache Pool, no effect. 4.0.110

Browse source
This commit is contained in:
winlin 2021-05-14 16:12:11 +08:00
parent d0951e2b43
commit f7b32252b0
16 changed files with 87 additions and 626 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -3679,7 +3679,7 @@ srs_error_t SrsConfig::check_normal_config()
string n = conf->at(i)->name;
if (n != "enabled" && n != "listen" && n != "dir" && n != "candidate" && n != "ecdsa"
&& n != "encrypt" && n != "reuseport" && n != "merge_nalus" && n != "perf_stat" && n != "black_hole"
&& n != "ip_family" && n != "rtp_cache" && n != "rtp_msg_cache") {
&& n != "ip_family") {
return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "illegal rtc_server.%s", n.c_str());
}
}
@ -5050,138 +5050,6 @@ bool SrsConfig::get_rtc_server_perf_stat()
return SRS_CONF_PERFER_FALSE(conf->arg0());
}
SrsConfDirective* SrsConfig::get_rtc_server_rtp_cache()
{
SrsConfDirective* conf = root->get("rtc_server");
if (!conf) {
return NULL;
}
conf = conf->get("rtp_cache");
if (!conf) {
return NULL;
}
return conf;
}
bool SrsConfig::get_rtc_server_rtp_cache_enabled()
{
static bool DEFAULT = true;
SrsConfDirective* conf = get_rtc_server_rtp_cache();
if (!conf) {
return DEFAULT;
}
conf = conf->get("enabled");
if (!conf || conf->arg0().empty()) {
return DEFAULT;
}
return SRS_CONF_PERFER_TRUE(conf->arg0());
}
uint64_t SrsConfig::get_rtc_server_rtp_cache_pkt_size()
{
int DEFAULT = 64 * 1024 * 1024;
SrsConfDirective* conf = get_rtc_server_rtp_cache();
if (!conf) {
return DEFAULT;
}
conf = conf->get("pkt_size");
if (!conf || conf->arg0().empty()) {
return DEFAULT;
}
return 1024 * (uint64_t)(1024 * ::atof(conf->arg0().c_str()));
}
uint64_t SrsConfig::get_rtc_server_rtp_cache_payload_size()
{
int DEFAULT = 16 * 1024 * 1024;
SrsConfDirective* conf = get_rtc_server_rtp_cache();
if (!conf) {
return DEFAULT;
}
conf = conf->get("payload_size");
if (!conf || conf->arg0().empty()) {
return DEFAULT;
}
return 1024 * (uint64_t)(1024 * ::atof(conf->arg0().c_str()));
}
SrsConfDirective* SrsConfig::get_rtc_server_rtp_msg_cache()
{
SrsConfDirective* conf = root->get("rtc_server");
if (!conf) {
return NULL;
}
conf = conf->get("rtp_msg_cache");
if (!conf) {
return NULL;
}
return conf;
}
bool SrsConfig::get_rtc_server_rtp_msg_cache_enabled()
{
static bool DEFAULT = true;
SrsConfDirective* conf = get_rtc_server_rtp_msg_cache();
if (!conf) {
return DEFAULT;
}
conf = conf->get("enabled");
if (!conf || conf->arg0().empty()) {
return DEFAULT;
}
return SRS_CONF_PERFER_TRUE(conf->arg0());
}
uint64_t SrsConfig::get_rtc_server_rtp_msg_cache_msg_size()
{
int DEFAULT = 16 * 1024 * 1024;
SrsConfDirective* conf = get_rtc_server_rtp_msg_cache();
if (!conf) {
return DEFAULT;
}
conf = conf->get("msg_size");
if (!conf || conf->arg0().empty()) {
return DEFAULT;
}
return 1024 * (uint64_t)(1024 * ::atof(conf->arg0().c_str()));
}
uint64_t SrsConfig::get_rtc_server_rtp_msg_cache_buffer_size()
{
int DEFAULT = 512 * 1024 * 1024;
SrsConfDirective* conf = get_rtc_server_rtp_msg_cache();
if (!conf) {
return DEFAULT;
}
conf = conf->get("buffer_size");
if (!conf || conf->arg0().empty()) {
return DEFAULT;
}
return 1024 * (uint64_t)(1024 * ::atof(conf->arg0().c_str()));
}
bool SrsConfig::get_rtc_server_black_hole()
{
static bool DEFAULT = false;

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

@ -543,18 +543,6 @@ public:
virtual int get_rtc_server_reuseport();
virtual bool get_rtc_server_merge_nalus();
virtual bool get_rtc_server_perf_stat();
private:
SrsConfDirective* get_rtc_server_rtp_cache();
public:
virtual bool get_rtc_server_rtp_cache_enabled();
virtual uint64_t get_rtc_server_rtp_cache_pkt_size();
virtual uint64_t get_rtc_server_rtp_cache_payload_size();
private:
virtual SrsConfDirective* get_rtc_server_rtp_msg_cache();
public:
virtual bool get_rtc_server_rtp_msg_cache_enabled();
virtual uint64_t get_rtc_server_rtp_msg_cache_msg_size();
virtual uint64_t get_rtc_server_rtp_msg_cache_buffer_size();
public:
virtual bool get_rtc_server_black_hole();
virtual std::string get_rtc_server_black_hole_addr();

21
trunk/src/app/srs_app_hybrid.cpp
View file

@ -443,29 +443,20 @@ srs_error_t SrsHybridServer::on_timer(srs_utime_t interval)
#endif
string objs_desc;
_srs_pps_objs_rtps->update(); _srs_pps_objs_rraw->update(); _srs_pps_objs_rfua->update(); _srs_pps_objs_rbuf->update(); _srs_pps_objs_msgs->update(); _srs_pps_objs_rothers->update(); _srs_pps_objs_drop->update();
if (_srs_pps_objs_rtps->r10s() || _srs_pps_objs_rraw->r10s() || _srs_pps_objs_rfua->r10s() || _srs_pps_objs_rbuf->r10s() || _srs_pps_objs_msgs->r10s() || _srs_pps_objs_rothers->r10s() || _srs_pps_objs_drop->r10s()) {
snprintf(buf, sizeof(buf), ", objs=(pkt:%d,raw:%d,fua:%d,msg:%d,oth:%d,buf:%d,drop:%d)",
_srs_pps_objs_rtps->update(); _srs_pps_objs_rraw->update(); _srs_pps_objs_rfua->update(); _srs_pps_objs_rbuf->update(); _srs_pps_objs_msgs->update(); _srs_pps_objs_rothers->update();
if (_srs_pps_objs_rtps->r10s() || _srs_pps_objs_rraw->r10s() || _srs_pps_objs_rfua->r10s() || _srs_pps_objs_rbuf->r10s() || _srs_pps_objs_msgs->r10s() || _srs_pps_objs_rothers->r10s()) {
snprintf(buf, sizeof(buf), ", objs=(pkt:%d,raw:%d,fua:%d,msg:%d,oth:%d,buf:%d)",
_srs_pps_objs_rtps->r10s(), _srs_pps_objs_rraw->r10s(), _srs_pps_objs_rfua->r10s(),
_srs_pps_objs_msgs->r10s(), _srs_pps_objs_rothers->r10s(), _srs_pps_objs_rbuf->r10s(), _srs_pps_objs_drop->r10s());
_srs_pps_objs_msgs->r10s(), _srs_pps_objs_rothers->r10s(), _srs_pps_objs_rbuf->r10s());
objs_desc = buf;
}
string cache_desc;
if (_srs_rtp_cache->size() || _srs_rtp_raw_cache->size() || _srs_rtp_fua_cache->size() || _srs_rtp_msg_cache_buffers->size() || _srs_rtp_msg_cache_objs->size()) {
snprintf(buf, sizeof(buf), ", cache=(pkt:%d-%dw,raw:%d-%dw,fua:%d-%dw,msg:%d-%dw,buf:%d-%dw)",
_srs_rtp_cache->size(), _srs_rtp_cache->capacity()/10000, _srs_rtp_raw_cache->size(), _srs_rtp_raw_cache->capacity()/10000,
_srs_rtp_fua_cache->size(), _srs_rtp_fua_cache->capacity()/10000, _srs_rtp_msg_cache_objs->size(), _srs_rtp_msg_cache_objs->capacity()/10000,
_srs_rtp_msg_cache_buffers->size(), _srs_rtp_msg_cache_buffers->capacity()/10000);
cache_desc = buf;
}
srs_trace("Hybrid cpu=%.2f%%,%dMB%s%s%s%s%s%s%s%s%s%s%s%s",
srs_trace("Hybrid cpu=%.2f%%,%dMB%s%s%s%s%s%s%s%s%s%s%s",
u->percent * 100, memory,
cid_desc.c_str(), timer_desc.c_str(),
recvfrom_desc.c_str(), io_desc.c_str(), msg_desc.c_str(),
epoll_desc.c_str(), sched_desc.c_str(), clock_desc.c_str(),
thread_desc.c_str(), free_desc.c_str(), objs_desc.c_str(), cache_desc.c_str()
thread_desc.c_str(), free_desc.c_str(), objs_desc.c_str()
);
return err;

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

@ -612,9 +612,9 @@ srs_error_t SrsRtcPlayStream::cycle()
srs_freep(err);
}
// Release the packet to cache.
// Free the packet.
// @remark Note that the pkt might be set to NULL.
_srs_rtp_cache->recycle(pkt);
srs_freep(pkt);
}
}
@ -1287,10 +1287,7 @@ srs_error_t SrsRtcPublishStream::on_rtp_plaintext(char* plaintext, int nb_plaint
}
// Allocate packet form cache.
SrsRtpPacket2* pkt = _srs_rtp_cache->allocate();
// It's better to reset it before decode it.
pkt->reset();
SrsRtpPacket2* pkt = new SrsRtpPacket2();
// Copy the packet body.
char* p = pkt->wrap(plaintext, nb_plaintext);
@ -1301,9 +1298,9 @@ srs_error_t SrsRtcPublishStream::on_rtp_plaintext(char* plaintext, int nb_plaint
// @remark Note that the pkt might be set to NULL.
err = do_on_rtp_plaintext(pkt, &buf);
// Release the packet to cache.
// Free the packet.
// @remark Note that the pkt might be set to NULL.
_srs_rtp_cache->recycle(pkt);
srs_freep(pkt);
return err;
}

11
trunk/src/app/srs_app_rtc_queue.cpp
View file

@ -55,7 +55,7 @@ SrsRtpRingBuffer::~SrsRtpRingBuffer()
{
for (int i = 0; i < capacity_; ++i) {
SrsRtpPacket2* pkt = queue_[i];
_srs_rtp_cache->recycle(pkt);
srs_freep(pkt);
}
srs_freepa(queue_);
}
@ -80,10 +80,7 @@ void SrsRtpRingBuffer::advance_to(uint16_t seq)
void SrsRtpRingBuffer::set(uint16_t at, SrsRtpPacket2* pkt)
{
SrsRtpPacket2* p = queue_[at % capacity_];
if (p) {
_srs_rtp_cache->recycle(p);
}
srs_freep(p);
queue_[at % capacity_] = pkt;
}
@ -170,7 +167,7 @@ void SrsRtpRingBuffer::clear_histroy(uint16_t seq)
for (uint16_t i = 0; i < capacity_; i++) {
SrsRtpPacket2* p = queue_[i];
if (p && p->header.get_sequence() < seq) {
_srs_rtp_cache->recycle(p);
srs_freep(p);
queue_[i] = NULL;
}
}
@ -181,7 +178,7 @@ void SrsRtpRingBuffer::clear_all_histroy()
for (uint16_t i = 0; i < capacity_; i++) {
SrsRtpPacket2* p = queue_[i];
if (p) {
_srs_rtp_cache->recycle(p);
srs_freep(p);
queue_[i] = NULL;
}
}

50
trunk/src/app/srs_app_rtc_server.cpp
View file

@ -289,61 +289,11 @@ srs_error_t SrsRtcServer::initialize()
return srs_error_wrap(err, "black hole");
}
bool rtp_cache_enabled = _srs_config->get_rtc_server_rtp_cache_enabled();
uint64_t rtp_cache_pkt_size = _srs_config->get_rtc_server_rtp_cache_pkt_size();
uint64_t rtp_cache_payload_size = _srs_config->get_rtc_server_rtp_cache_payload_size();
_srs_rtp_cache->setup(rtp_cache_enabled, rtp_cache_pkt_size);
_srs_rtp_raw_cache->setup(rtp_cache_enabled, rtp_cache_payload_size);
_srs_rtp_fua_cache->setup(rtp_cache_enabled, rtp_cache_payload_size);
bool rtp_msg_cache_enabled = _srs_config->get_rtc_server_rtp_msg_cache_enabled();
uint64_t rtp_msg_cache_msg_size = _srs_config->get_rtc_server_rtp_msg_cache_msg_size();
uint64_t rtp_msg_cache_buffer_size = _srs_config->get_rtc_server_rtp_msg_cache_buffer_size();
_srs_rtp_msg_cache_buffers->setup(rtp_msg_cache_enabled, rtp_msg_cache_buffer_size);
_srs_rtp_msg_cache_objs->setup(rtp_msg_cache_enabled, rtp_msg_cache_msg_size);
srs_trace("RTC: Object cache init, rtp-cache=(enabled:%d,pkt:%dm-%dw,payload:%dm-%dw-%dw), msg-cache=(enabled:%d,obj:%dm-%dw,buf:%dm-%dw)",
rtp_cache_enabled, (int)(rtp_cache_pkt_size/1024/1024), _srs_rtp_cache->capacity()/10000,
(int)(rtp_cache_payload_size/1024/1024), _srs_rtp_raw_cache->capacity()/10000, _srs_rtp_fua_cache->capacity()/10000,
rtp_msg_cache_enabled, (int)(rtp_msg_cache_msg_size/1024/1024), _srs_rtp_msg_cache_objs->capacity()/10000,
(int)(rtp_msg_cache_buffer_size/1024/1024), _srs_rtp_msg_cache_buffers->capacity()/10000);
return err;
}
srs_error_t SrsRtcServer::on_reload_rtc_server()
{
bool changed = false;
bool rtp_cache_enabled = _srs_config->get_rtc_server_rtp_cache_enabled();
uint64_t rtp_cache_pkt_size = _srs_config->get_rtc_server_rtp_cache_pkt_size();
uint64_t rtp_cache_payload_size = _srs_config->get_rtc_server_rtp_cache_payload_size();
if (_srs_rtp_cache->enabled() != rtp_cache_enabled) {
_srs_rtp_cache->setup(rtp_cache_enabled, rtp_cache_pkt_size);
_srs_rtp_raw_cache->setup(rtp_cache_enabled, rtp_cache_payload_size);
_srs_rtp_fua_cache->setup(rtp_cache_enabled, rtp_cache_payload_size);
changed = true;
}
bool rtp_msg_cache_enabled = _srs_config->get_rtc_server_rtp_msg_cache_enabled();
uint64_t rtp_msg_cache_msg_size = _srs_config->get_rtc_server_rtp_msg_cache_msg_size();
uint64_t rtp_msg_cache_buffer_size = _srs_config->get_rtc_server_rtp_msg_cache_buffer_size();
if (_srs_rtp_msg_cache_buffers->enabled() != rtp_msg_cache_enabled) {
_srs_rtp_msg_cache_buffers->setup(rtp_msg_cache_enabled, rtp_msg_cache_buffer_size);
_srs_rtp_msg_cache_objs->setup(rtp_msg_cache_enabled, rtp_msg_cache_msg_size);
changed = true;
}
if (changed) {
srs_trace("RTC: Object cache reload, rtp-cache=(enabled:%d,pkt:%dm-%dw,payload:%dm-%dw-%dw), msg-cache=(enabled:%d,obj:%dm-%dw,buf:%dm-%dw)",
rtp_cache_enabled, (int)(rtp_cache_pkt_size/1024/1024), _srs_rtp_cache->capacity()/10000,
(int)(rtp_cache_payload_size/1024/1024), _srs_rtp_raw_cache->capacity()/10000, _srs_rtp_fua_cache->capacity()/10000,
rtp_msg_cache_enabled, (int)(rtp_msg_cache_msg_size/1024/1024), _srs_rtp_msg_cache_objs->capacity()/10000,
(int)(rtp_msg_cache_buffer_size/1024/1024), _srs_rtp_msg_cache_buffers->capacity()/10000);
}
return srs_success;
}

117
trunk/src/app/srs_app_rtc_source.cpp
View file

@ -178,7 +178,7 @@ SrsRtcConsumer::~SrsRtcConsumer()
vector<SrsRtpPacket2*>::iterator it;
for (it = queue.begin(); it != queue.end(); ++it) {
SrsRtpPacket2* pkt = *it;
_srs_rtp_cache->recycle(pkt);
srs_freep(pkt);
}
srs_cond_destroy(mw_wait);
@ -661,19 +661,6 @@ srs_error_t SrsRtcStream::on_timer(srs_utime_t interval)
return err;
}
SrsRtpPacketCacheHelper::SrsRtpPacketCacheHelper()
{
pkt = _srs_rtp_cache->allocate();
// We MUST reset the packet, when got from cache.
pkt->reset();
}
SrsRtpPacketCacheHelper::~SrsRtpPacketCacheHelper()
{
_srs_rtp_cache->recycle(pkt);
}
#ifdef SRS_FFMPEG_FIT
SrsRtcFromRtmpBridger::SrsRtcFromRtmpBridger(SrsRtcStream* source)
{
@ -844,45 +831,46 @@ srs_error_t SrsRtcFromRtmpBridger::on_audio(SrsSharedPtrMessage* msg)
return err;
}
srs_error_t SrsRtcFromRtmpBridger::transcode(SrsAudioFrame* pkt)
srs_error_t SrsRtcFromRtmpBridger::transcode(SrsAudioFrame* audio)
{
srs_error_t err = srs_success;
std::vector<SrsAudioFrame *> out_pkts;
if ((err = codec_->transcode(pkt, out_pkts)) != srs_success) {
std::vector<SrsAudioFrame *> out_audios;
if ((err = codec_->transcode(audio, out_audios)) != srs_success) {
return srs_error_wrap(err, "recode error");
}
// Save OPUS packets in shared message.
if (out_pkts.empty()) {
if (out_audios.empty()) {
return err;
}
for (std::vector<SrsAudioFrame *>::iterator it = out_pkts.begin(); it != out_pkts.end(); ++it) {
SrsRtpPacketCacheHelper* helper = new SrsRtpPacketCacheHelper();
SrsAutoFree(SrsRtpPacketCacheHelper, helper);
for (std::vector<SrsAudioFrame*>::iterator it = out_audios.begin(); it != out_audios.end(); ++it) {
SrsAudioFrame* out_audio = *it;
if ((err = package_opus(*it, helper)) != srs_success) {
SrsRtpPacket2* pkt = new SrsRtpPacket2();
SrsAutoFree(SrsRtpPacket2, pkt);
if ((err = package_opus(out_audio, pkt)) != srs_success) {
err = srs_error_wrap(err, "package opus");
break;
}
if ((err = source_->on_rtp(helper->pkt)) != srs_success) {
if ((err = source_->on_rtp(pkt)) != srs_success) {
err = srs_error_wrap(err, "consume opus");
break;
}
}
codec_->free_frames(out_pkts);
codec_->free_frames(out_audios);
return err;
}
srs_error_t SrsRtcFromRtmpBridger::package_opus(SrsAudioFrame* audio, SrsRtpPacketCacheHelper* helper)
srs_error_t SrsRtcFromRtmpBridger::package_opus(SrsAudioFrame* audio, SrsRtpPacket2* pkt)
{
srs_error_t err = srs_success;
SrsRtpPacket2* pkt = helper->pkt;
pkt->header.set_payload_type(kAudioPayloadType);
pkt->header.set_ssrc(audio_ssrc);
pkt->frame_type = SrsFrameTypeAudio;
@ -890,7 +878,7 @@ srs_error_t SrsRtcFromRtmpBridger::package_opus(SrsAudioFrame* audio, SrsRtpPack
pkt->header.set_sequence(audio_sequence++);
pkt->header.set_timestamp(audio->dts * 48);
SrsRtpRawPayload* raw = _srs_rtp_raw_cache->allocate();
SrsRtpRawPayload* raw = new SrsRtpRawPayload();
pkt->set_payload(raw, SrsRtpPacketPayloadTypeRaw);
srs_assert(audio->nb_samples == 1);
@ -923,22 +911,22 @@ srs_error_t SrsRtcFromRtmpBridger::on_video(SrsSharedPtrMessage* msg)
// Well, for each IDR, we append a SPS/PPS before it, which is packaged in STAP-A.
if (has_idr) {
SrsRtpPacketCacheHelper* helper = new SrsRtpPacketCacheHelper();
SrsAutoFree(SrsRtpPacketCacheHelper, helper);
SrsRtpPacket2* pkt = new SrsRtpPacket2();
SrsAutoFree(SrsRtpPacket2, pkt);
if ((err = package_stap_a(source_, msg, helper)) != srs_success) {
if ((err = package_stap_a(source_, msg, pkt)) != srs_success) {
return srs_error_wrap(err, "package stap-a");
}
if ((err = source_->on_rtp(helper->pkt)) != srs_success) {
if ((err = source_->on_rtp(pkt)) != srs_success) {
return srs_error_wrap(err, "consume sps/pps");
}
}
// If merge Nalus, we pcakges all NALUs(samples) as one NALU, in a RTP or FUA packet.
vector<SrsRtpPacketCacheHelper*> helpers;
vector<SrsRtpPacket2*> pkts;
if (merge_nalus && nn_samples > 1) {
if ((err = package_nalus(msg, samples, helpers)) != srs_success) {
if ((err = package_nalus(msg, samples, pkts)) != srs_success) {
return srs_error_wrap(err, "package nalus as one");
}
} else {
@ -953,22 +941,22 @@ srs_error_t SrsRtcFromRtmpBridger::on_video(SrsSharedPtrMessage* msg)
}
if (sample->size <= kRtpMaxPayloadSize) {
if ((err = package_single_nalu(msg, sample, helpers)) != srs_success) {
if ((err = package_single_nalu(msg, sample, pkts)) != srs_success) {
return srs_error_wrap(err, "package single nalu");
}
} else {
if ((err = package_fu_a(msg, sample, kRtpMaxPayloadSize, helpers)) != srs_success) {
if ((err = package_fu_a(msg, sample, kRtpMaxPayloadSize, pkts)) != srs_success) {
return srs_error_wrap(err, "package fu-a");
}
}
}
}
if (!helpers.empty()) {
helpers.back()->pkt->header.set_marker(true);
if (!pkts.empty()) {
pkts.back()->header.set_marker(true);
}
return consume_packets(helpers);
return consume_packets(pkts);
}
srs_error_t SrsRtcFromRtmpBridger::filter(SrsSharedPtrMessage* msg, SrsFormat* format, bool& has_idr, vector<SrsSample*>& samples)
@ -1001,7 +989,7 @@ srs_error_t SrsRtcFromRtmpBridger::filter(SrsSharedPtrMessage* msg, SrsFormat* f
return err;
}
srs_error_t SrsRtcFromRtmpBridger::package_stap_a(SrsRtcStream* source, SrsSharedPtrMessage* msg, SrsRtpPacketCacheHelper* helper)
srs_error_t SrsRtcFromRtmpBridger::package_stap_a(SrsRtcStream* source, SrsSharedPtrMessage* msg, SrsRtpPacket2* pkt)
{
srs_error_t err = srs_success;
@ -1017,7 +1005,6 @@ srs_error_t SrsRtcFromRtmpBridger::package_stap_a(SrsRtcStream* source, SrsShare
return srs_error_new(ERROR_RTC_RTP_MUXER, "sps/pps empty");
}
SrsRtpPacket2* pkt = helper->pkt;
pkt->header.set_payload_type(kVideoPayloadType);
pkt->header.set_ssrc(video_ssrc);
pkt->frame_type = SrsFrameTypeVideo;
@ -1061,7 +1048,7 @@ srs_error_t SrsRtcFromRtmpBridger::package_stap_a(SrsRtcStream* source, SrsShare
return err;
}
srs_error_t SrsRtcFromRtmpBridger::package_nalus(SrsSharedPtrMessage* msg, const vector<SrsSample*>& samples, vector<SrsRtpPacketCacheHelper*>& helpers)
srs_error_t SrsRtcFromRtmpBridger::package_nalus(SrsSharedPtrMessage* msg, const vector<SrsSample*>& samples, vector<SrsRtpPacket2*>& pkts)
{
srs_error_t err = srs_success;
@ -1097,10 +1084,9 @@ srs_error_t SrsRtcFromRtmpBridger::package_nalus(SrsSharedPtrMessage* msg, const
if (nn_bytes < kRtpMaxPayloadSize) {
// Package NALUs in a single RTP packet.
SrsRtpPacketCacheHelper* helper = new SrsRtpPacketCacheHelper();
helpers.push_back(helper);
SrsRtpPacket2* pkt = new SrsRtpPacket2();
pkts.push_back(pkt);
SrsRtpPacket2* pkt = helper->pkt;
pkt->header.set_payload_type(kVideoPayloadType);
pkt->header.set_ssrc(video_ssrc);
pkt->frame_type = SrsFrameTypeVideo;
@ -1132,10 +1118,9 @@ srs_error_t SrsRtcFromRtmpBridger::package_nalus(SrsSharedPtrMessage* msg, const
return srs_error_wrap(err, "read samples %d bytes, left %d, total %d", packet_size, nb_left, nn_bytes);
}
SrsRtpPacketCacheHelper* helper = new SrsRtpPacketCacheHelper();
helpers.push_back(helper);
SrsRtpPacket2* pkt = new SrsRtpPacket2();
pkts.push_back(pkt);
SrsRtpPacket2* pkt = helper->pkt;
pkt->header.set_payload_type(kVideoPayloadType);
pkt->header.set_ssrc(video_ssrc);
pkt->frame_type = SrsFrameTypeVideo;
@ -1159,21 +1144,20 @@ srs_error_t SrsRtcFromRtmpBridger::package_nalus(SrsSharedPtrMessage* msg, const
}
// Single NAL Unit Packet @see https://tools.ietf.org/html/rfc6184#section-5.6
srs_error_t SrsRtcFromRtmpBridger::package_single_nalu(SrsSharedPtrMessage* msg, SrsSample* sample, vector<SrsRtpPacketCacheHelper*>& helpers)
srs_error_t SrsRtcFromRtmpBridger::package_single_nalu(SrsSharedPtrMessage* msg, SrsSample* sample, vector<SrsRtpPacket2*>& pkts)
{
srs_error_t err = srs_success;
SrsRtpPacketCacheHelper* helper = new SrsRtpPacketCacheHelper();
helpers.push_back(helper);
SrsRtpPacket2* pkt = new SrsRtpPacket2();
pkts.push_back(pkt);
SrsRtpPacket2* pkt = helper->pkt;
pkt->header.set_payload_type(kVideoPayloadType);
pkt->header.set_ssrc(video_ssrc);
pkt->frame_type = SrsFrameTypeVideo;
pkt->header.set_sequence(video_sequence++);
pkt->header.set_timestamp(msg->timestamp * 90);
SrsRtpRawPayload* raw = _srs_rtp_raw_cache->allocate();
SrsRtpRawPayload* raw = new SrsRtpRawPayload();
pkt->set_payload(raw, SrsRtpPacketPayloadTypeRaw);
raw->payload = sample->bytes;
@ -1184,7 +1168,7 @@ srs_error_t SrsRtcFromRtmpBridger::package_single_nalu(SrsSharedPtrMessage* msg,
return err;
}
srs_error_t SrsRtcFromRtmpBridger::package_fu_a(SrsSharedPtrMessage* msg, SrsSample* sample, int fu_payload_size, vector<SrsRtpPacketCacheHelper*>& helpers)
srs_error_t SrsRtcFromRtmpBridger::package_fu_a(SrsSharedPtrMessage* msg, SrsSample* sample, int fu_payload_size, vector<SrsRtpPacket2*>& pkts)
{
srs_error_t err = srs_success;
@ -1197,17 +1181,16 @@ srs_error_t SrsRtcFromRtmpBridger::package_fu_a(SrsSharedPtrMessage* msg, SrsSam
for (int i = 0; i < num_of_packet; ++i) {
int packet_size = srs_min(nb_left, fu_payload_size);
SrsRtpPacketCacheHelper* helper = new SrsRtpPacketCacheHelper();
helpers.push_back(helper);
SrsRtpPacket2* pkt = new SrsRtpPacket2();
pkts.push_back(pkt);
SrsRtpPacket2* pkt = helper->pkt;
pkt->header.set_payload_type(kVideoPayloadType);
pkt->header.set_ssrc(video_ssrc);
pkt->frame_type = SrsFrameTypeVideo;
pkt->header.set_sequence(video_sequence++);
pkt->header.set_timestamp(msg->timestamp * 90);
SrsRtpFUAPayload2* fua = _srs_rtp_fua_cache->allocate();
SrsRtpFUAPayload2* fua = new SrsRtpFUAPayload2();
pkt->set_payload(fua, SrsRtpPacketPayloadTypeFUA2);
fua->nri = (SrsAvcNaluType)header;
@ -1227,22 +1210,22 @@ srs_error_t SrsRtcFromRtmpBridger::package_fu_a(SrsSharedPtrMessage* msg, SrsSam
return err;
}
srs_error_t SrsRtcFromRtmpBridger::consume_packets(vector<SrsRtpPacketCacheHelper*>& helpers)
srs_error_t SrsRtcFromRtmpBridger::consume_packets(vector<SrsRtpPacket2*>& pkts)
{
srs_error_t err = srs_success;
// TODO: FIXME: Consume a range of packets.
for (int i = 0; i < (int)helpers.size(); i++) {
SrsRtpPacketCacheHelper* helper = helpers[i];
if ((err = source_->on_rtp(helper->pkt)) != srs_success) {
for (int i = 0; i < (int)pkts.size(); i++) {
SrsRtpPacket2* pkt = pkts[i];
if ((err = source_->on_rtp(pkt)) != srs_success) {
err = srs_error_wrap(err, "consume sps/pps");
break;
}
}
for (int i = 0; i < (int)helpers.size(); i++) {
SrsRtpPacketCacheHelper* helper = helpers[i];
srs_freep(helper);
for (int i = 0; i < (int)pkts.size(); i++) {
SrsRtpPacket2* pkt = pkts[i];
srs_freep(pkt);
}
return err;
@ -2341,7 +2324,7 @@ void SrsRtcAudioRecvTrack::on_before_decode_payload(SrsRtpPacket2* pkt, SrsBuffe
return;
}
*ppayload = _srs_rtp_raw_cache->allocate();
*ppayload = new SrsRtpRawPayload();
*ppt = SrsRtpPacketPayloadTypeRaw;
}
@ -2393,10 +2376,10 @@ void SrsRtcVideoRecvTrack::on_before_decode_payload(SrsRtpPacket2* pkt, SrsBuffe
*ppayload = new SrsRtpSTAPPayload();
*ppt = SrsRtpPacketPayloadTypeSTAP;
} else if (v == kFuA) {
*ppayload = _srs_rtp_fua_cache->allocate();
*ppayload = new SrsRtpFUAPayload2();
*ppt = SrsRtpPacketPayloadTypeFUA2;
} else {
*ppayload = _srs_rtp_raw_cache->allocate();
*ppayload = new SrsRtpRawPayload();
*ppt = SrsRtpPacketPayloadTypeRaw;
}
}

23
trunk/src/app/srs_app_rtc_source.hpp
View file

@ -47,7 +47,6 @@ class SrsRtcStream;
class SrsRtcFromRtmpBridger;
class SrsAudioTranscoder;
class SrsRtpPacket2;
class SrsRtpPacketCacheHelper;
class SrsSample;
class SrsRtcStreamDescription;
class SrsRtcTrackDescription;
@ -259,16 +258,6 @@ private:
srs_error_t on_timer(srs_utime_t interval);
};
// A helper class, to release the packet to cache.
class SrsRtpPacketCacheHelper
{
public:
SrsRtpPacket2* pkt;
public:
SrsRtpPacketCacheHelper();
virtual ~SrsRtpPacketCacheHelper();
};
#ifdef SRS_FFMPEG_FIT
class SrsRtcFromRtmpBridger : public ISrsSourceBridger
{
@ -298,16 +287,16 @@ public:
virtual srs_error_t on_audio(SrsSharedPtrMessage* msg);
private:
srs_error_t transcode(SrsAudioFrame* audio);
srs_error_t package_opus(SrsAudioFrame* audio, SrsRtpPacketCacheHelper* helper);
srs_error_t package_opus(SrsAudioFrame* audio, SrsRtpPacket2* pkt);
public:
virtual srs_error_t on_video(SrsSharedPtrMessage* msg);
private:
srs_error_t filter(SrsSharedPtrMessage* msg, SrsFormat* format, bool& has_idr, std::vector<SrsSample*>& samples);
srs_error_t package_stap_a(SrsRtcStream* source, SrsSharedPtrMessage* msg, SrsRtpPacketCacheHelper* helper);
srs_error_t package_nalus(SrsSharedPtrMessage* msg, const std::vector<SrsSample*>& samples, std::vector<SrsRtpPacketCacheHelper*>& helpers);
srs_error_t package_single_nalu(SrsSharedPtrMessage* msg, SrsSample* sample, std::vector<SrsRtpPacketCacheHelper*>& helpers);
srs_error_t package_fu_a(SrsSharedPtrMessage* msg, SrsSample* sample, int fu_payload_size, std::vector<SrsRtpPacketCacheHelper*>& helpers);
srs_error_t consume_packets(std::vector<SrsRtpPacketCacheHelper*>& helpers);
srs_error_t package_stap_a(SrsRtcStream* source, SrsSharedPtrMessage* msg, SrsRtpPacket2* pkt);
srs_error_t package_nalus(SrsSharedPtrMessage* msg, const std::vector<SrsSample*>& samples, std::vector<SrsRtpPacket2*>& pkts);
srs_error_t package_single_nalu(SrsSharedPtrMessage* msg, SrsSample* sample, std::vector<SrsRtpPacket2*>& pkts);
srs_error_t package_fu_a(SrsSharedPtrMessage* msg, SrsSample* sample, int fu_payload_size, std::vector<SrsRtpPacket2*>& pkts);
srs_error_t consume_packets(std::vector<SrsRtpPacket2*>& pkts);
};
class SrsRtmpFromRtcBridger : public ISrsRtcSourceBridger

16
trunk/src/app/srs_app_threads.cpp
View file

@ -46,13 +46,6 @@ extern SrsStageManager* _srs_stages;
extern SrsRtcBlackhole* _srs_blackhole;
extern SrsResourceManager* _srs_rtc_manager;
extern SrsRtpObjectCacheManager<SrsRtpPacket2>* _srs_rtp_cache;
extern SrsRtpObjectCacheManager<SrsRtpRawPayload>* _srs_rtp_raw_cache;
extern SrsRtpObjectCacheManager<SrsRtpFUAPayload2>* _srs_rtp_fua_cache;
extern SrsRtpObjectCacheManager<SrsSharedPtrMessage>* _srs_rtp_msg_cache_buffers;
extern SrsRtpObjectCacheManager<SrsSharedPtrMessage>* _srs_rtp_msg_cache_objs;
extern SrsResourceManager* _srs_rtc_manager;
extern SrsDtlsCertificate* _srs_rtc_dtls_certificate;
@ -166,7 +159,6 @@ extern SrsPps* _srs_pps_objs_rraw;
extern SrsPps* _srs_pps_objs_rfua;
extern SrsPps* _srs_pps_objs_rbuf;
extern SrsPps* _srs_pps_objs_rothers;
extern SrsPps* _srs_pps_objs_drop;
SrsCircuitBreaker::SrsCircuitBreaker()
{
@ -306,13 +298,6 @@ srs_error_t srs_thread_initialize()
_srs_rtc_manager = new SrsResourceManager("RTC", true);
_srs_circuit_breaker = new SrsCircuitBreaker();
_srs_rtp_cache = new SrsRtpObjectCacheManager<SrsRtpPacket2>(sizeof(SrsRtpPacket2));
_srs_rtp_raw_cache = new SrsRtpObjectCacheManager<SrsRtpRawPayload>(sizeof(SrsRtpRawPayload));
_srs_rtp_fua_cache = new SrsRtpObjectCacheManager<SrsRtpFUAPayload2>(sizeof(SrsRtpFUAPayload2));
_srs_rtp_msg_cache_buffers = new SrsRtpObjectCacheManager<SrsSharedPtrMessage>(sizeof(SrsSharedPtrMessage) + kRtpPacketSize);
_srs_rtp_msg_cache_objs = new SrsRtpObjectCacheManager<SrsSharedPtrMessage>(sizeof(SrsSharedPtrMessage));
_srs_rtc_manager = new SrsResourceManager("RTC", true);
_srs_rtc_dtls_certificate = new SrsDtlsCertificate();
@ -416,7 +401,6 @@ srs_error_t srs_thread_initialize()
_srs_pps_objs_rfua = new SrsPps();
_srs_pps_objs_rbuf = new SrsPps();
_srs_pps_objs_rothers = new SrsPps();
_srs_pps_objs_drop = new SrsPps();
return err;
}