external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-02-13 20:01:56 +00:00
Code Issues Releases Wiki Activity

add rtp shared packet

Browse source
This commit is contained in:
xiaozhihong 2020-03-13 20:34:40 +08:00
parent 6decdc7838
commit 027d34bbd3
8 changed files with 51 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
trunk/configure vendored
View file

@ -204,7 +204,7 @@ MODULE_ID="KERNEL"
MODULE_DEPENDS=("CORE") MODULE_DEPENDS=("CORE")
ModuleLibIncs=(${SRS_OBJS_DIR} ${LibSSLRoot}) ModuleLibIncs=(${SRS_OBJS_DIR} ${LibSSLRoot})
MODULE_FILES=("srs_kernel_error" "srs_kernel_log" "srs_kernel_buffer" MODULE_FILES=("srs_kernel_error" "srs_kernel_log" "srs_kernel_buffer"
"srs_kernel_utility" "srs_kernel_flv" "srs_kernel_codec" "srs_kernel_io" "srs_kernel_utility" "srs_kernel_flv" "srs_kernel_rtp" "srs_kernel_codec" "srs_kernel_io"
"srs_kernel_consts" "srs_kernel_aac" "srs_kernel_mp3" "srs_kernel_ts" "srs_kernel_consts" "srs_kernel_aac" "srs_kernel_mp3" "srs_kernel_ts"
"srs_kernel_stream" "srs_kernel_balance" "srs_kernel_mp4" "srs_kernel_file") "srs_kernel_stream" "srs_kernel_balance" "srs_kernel_mp4" "srs_kernel_file")
KERNEL_INCS="src/kernel"; MODULE_DIR=${KERNEL_INCS} . auto/modules.sh KERNEL_INCS="src/kernel"; MODULE_DIR=${KERNEL_INCS} . auto/modules.sh

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

@ -37,6 +37,7 @@ using namespace std;
#include <srs_core_autofree.hpp> #include <srs_core_autofree.hpp>
#include <srs_kernel_buffer.hpp> #include <srs_kernel_buffer.hpp>
#include <srs_kernel_rtp.hpp>
#include <srs_kernel_error.hpp> #include <srs_kernel_error.hpp>
#include <srs_kernel_log.hpp> #include <srs_kernel_log.hpp>
#include <srs_stun_stack.hpp> #include <srs_stun_stack.hpp>
@ -682,12 +683,12 @@ void SrsRtcSenderThread::send_and_free_messages(SrsSharedPtrMessage** msgs, int
for (int i = 0; i < nb_msgs; i++) { for (int i = 0; i < nb_msgs; i++) {
SrsSharedPtrMessage* msg = msgs[i]; SrsSharedPtrMessage* msg = msgs[i];
for (int i = 0; i < msg->nb_rtp_fragments; ++i) { for (int i = 0; i < msg->rtp_packets.size(); ++i) {
if (rtc_session->dtls_session) { if (rtc_session->dtls_session) {
char protected_buf[kRtpPacketSize]; char protected_buf[kRtpPacketSize];
int nb_protected_buf = msg->rtp_fragments[i].size; int nb_protected_buf = msg->rtp_packets[i]->size;
rtc_session->dtls_session->protect_rtp(protected_buf, msg->rtp_fragments[i].bytes, nb_protected_buf); rtc_session->dtls_session->protect_rtp(protected_buf, msg->rtp_packets[i]->payload, nb_protected_buf);
udp_mux_skt->sendto(protected_buf, nb_protected_buf, 0); udp_mux_skt->sendto(protected_buf, nb_protected_buf, 0);
} }
} }

51
trunk/src/app/srs_app_rtp.cpp
View file

@ -38,6 +38,7 @@ using namespace std;
#include <srs_kernel_error.hpp> #include <srs_kernel_error.hpp>
#include <srs_kernel_codec.hpp> #include <srs_kernel_codec.hpp>
#include <srs_kernel_flv.hpp> #include <srs_kernel_flv.hpp>
#include <srs_kernel_rtp.hpp>
#include <srs_app_config.hpp> #include <srs_app_config.hpp>
#include <srs_app_source.hpp> #include <srs_app_source.hpp>
#include <srs_core_autofree.hpp> #include <srs_core_autofree.hpp>
@ -68,7 +69,7 @@ srs_error_t SrsRtpMuxer::frame_to_packet(SrsSharedPtrMessage* shared_frame, SrsF
pps.assign(format->vcodec->pictureParameterSetNALUnit.data(), format->vcodec->pictureParameterSetNALUnit.size()); pps.assign(format->vcodec->pictureParameterSetNALUnit.data(), format->vcodec->pictureParameterSetNALUnit.size());
} }
vector<SrsSample> rtp_packet_vec; vector<SrsRtpSharedPacket*> rtp_packet_vec;
for (int i = 0; i < format->video->nb_samples; ++i) { for (int i = 0; i < format->video->nb_samples; ++i) {
SrsSample sample = format->video->samples[i]; SrsSample sample = format->video->samples[i];
@ -95,17 +96,12 @@ srs_error_t SrsRtpMuxer::frame_to_packet(SrsSharedPtrMessage* shared_frame, SrsF
#endif #endif
} }
SrsSample* rtp_samples = new SrsSample[rtp_packet_vec.size()]; shared_frame->set_rtp_packets(rtp_packet_vec);
for (int i = 0; i < rtp_packet_vec.size(); ++i) {
rtp_samples[i] = rtp_packet_vec[i];
}
shared_frame->set_rtp_fragments(rtp_samples, rtp_packet_vec.size());
return err; return err;
} }
srs_error_t SrsRtpMuxer::packet_fu_a(SrsSharedPtrMessage* shared_frame, SrsFormat* format, SrsSample* sample, vector<SrsSample>& rtp_packet_vec) srs_error_t SrsRtpMuxer::packet_fu_a(SrsSharedPtrMessage* shared_frame, SrsFormat* format, SrsSample* sample, vector<SrsRtpSharedPacket*>& rtp_packet_vec)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
@ -136,7 +132,7 @@ srs_error_t SrsRtpMuxer::packet_fu_a(SrsSharedPtrMessage* shared_frame, SrsForma
stream->write_1bytes(kH264PayloadType); stream->write_1bytes(kH264PayloadType);
} }
// sequence // sequence
stream->write_2bytes(sequence++); stream->write_2bytes(sequence);
// timestamp // timestamp
stream->write_4bytes(int32_t(shared_frame->timestamp * 90)); stream->write_4bytes(int32_t(shared_frame->timestamp * 90));
// ssrc // ssrc
@ -159,15 +155,14 @@ srs_error_t SrsRtpMuxer::packet_fu_a(SrsSharedPtrMessage* shared_frame, SrsForma
nb_left -= packet_size; nb_left -= packet_size;
SrsSample rtp_packet; SrsRtpSharedPacket* rtp_shared_pkt = new SrsRtpSharedPacket();
rtp_packet.bytes = stream->data(); rtp_shared_pkt->create((shared_frame->timestamp * 90), sequence++, kVideoSSRC, kH264PayloadType, stream->data(), stream->pos());
rtp_packet.size = stream->pos();
rtp_packet_vec.push_back(rtp_packet); rtp_packet_vec.push_back(rtp_shared_pkt);
} }
} }
srs_error_t SrsRtpMuxer::packet_single_nalu(SrsSharedPtrMessage* shared_frame, SrsFormat* format, SrsSample* sample, vector<SrsSample>& rtp_packet_vec) srs_error_t SrsRtpMuxer::packet_single_nalu(SrsSharedPtrMessage* shared_frame, SrsFormat* format, SrsSample* sample, vector<SrsRtpSharedPacket*>& rtp_packet_vec)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
@ -187,7 +182,7 @@ srs_error_t SrsRtpMuxer::packet_single_nalu(SrsSharedPtrMessage* shared_frame, S
// marker payloadtype // marker payloadtype
stream->write_1bytes(kMarker | kH264PayloadType); stream->write_1bytes(kMarker | kH264PayloadType);
// sequenct // sequenct
stream->write_2bytes(sequence++); stream->write_2bytes(sequence);
// timestamp // timestamp
stream->write_4bytes(int32_t(shared_frame->timestamp * 90)); stream->write_4bytes(int32_t(shared_frame->timestamp * 90));
// ssrc // ssrc
@ -195,16 +190,15 @@ srs_error_t SrsRtpMuxer::packet_single_nalu(SrsSharedPtrMessage* shared_frame, S
stream->write_bytes(sample->bytes, sample->size); stream->write_bytes(sample->bytes, sample->size);
SrsSample rtp_packet; SrsRtpSharedPacket* rtp_shared_pkt = new SrsRtpSharedPacket();
rtp_packet.bytes = stream->data(); rtp_shared_pkt->create((shared_frame->timestamp * 90), sequence++, kVideoSSRC, kH264PayloadType, stream->data(), stream->pos());
rtp_packet.size = stream->pos();
rtp_packet_vec.push_back(rtp_packet); rtp_packet_vec.push_back(rtp_shared_pkt);
return err; return err;
} }
srs_error_t SrsRtpMuxer::packet_stap_a(const string &sps, const string& pps, SrsSharedPtrMessage* shared_frame, vector<SrsSample>& rtp_packet_vec) srs_error_t SrsRtpMuxer::packet_stap_a(const string &sps, const string& pps, SrsSharedPtrMessage* shared_frame, vector<SrsRtpSharedPacket*>& rtp_packet_vec)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
@ -220,7 +214,7 @@ srs_error_t SrsRtpMuxer::packet_stap_a(const string &sps, const string& pps, Srs
// marker payloadtype // marker payloadtype
stream->write_1bytes(kMarker | kH264PayloadType); stream->write_1bytes(kMarker | kH264PayloadType);
// sequenct // sequenct
stream->write_2bytes(sequence++); stream->write_2bytes(sequence);
// timestamp // timestamp
stream->write_4bytes(int32_t(shared_frame->timestamp * 90)); stream->write_4bytes(int32_t(shared_frame->timestamp * 90));
// ssrc // ssrc
@ -237,11 +231,10 @@ srs_error_t SrsRtpMuxer::packet_stap_a(const string &sps, const string& pps, Srs
stream->write_2bytes(pps.size()); stream->write_2bytes(pps.size());
stream->write_bytes((char*)pps.data(), pps.size()); stream->write_bytes((char*)pps.data(), pps.size());
SrsSample rtp_packet; SrsRtpSharedPacket* rtp_shared_pkt = new SrsRtpSharedPacket();
rtp_packet.bytes = stream->data(); rtp_shared_pkt->create((shared_frame->timestamp * 90), sequence++, kVideoSSRC, kH264PayloadType, stream->data(), stream->pos());
rtp_packet.size = stream->pos();
rtp_packet_vec.push_back(rtp_packet); rtp_packet_vec.push_back(rtp_shared_pkt);
return err; return err;
} }
@ -336,9 +329,6 @@ srs_error_t SrsRtp::on_audio(SrsSharedPtrMessage* shared_audio, SrsFormat* forma
// update the hls time, for hls_dispose. // update the hls time, for hls_dispose.
last_update_time = srs_get_system_time(); last_update_time = srs_get_system_time();
SrsSharedPtrMessage* audio = shared_audio->copy();
SrsAutoFree(SrsSharedPtrMessage, audio);
// ts support audio codec: aac/mp3 // ts support audio codec: aac/mp3
SrsAudioCodecId acodec = format->acodec->id; SrsAudioCodecId acodec = format->acodec->id;
if (acodec != SrsAudioCodecIdAAC && acodec != SrsAudioCodecIdMP3) { if (acodec != SrsAudioCodecIdAAC && acodec != SrsAudioCodecIdMP3) {
@ -369,11 +359,8 @@ srs_error_t SrsRtp::on_video(SrsSharedPtrMessage* shared_video, SrsFormat* forma
// update the hls time, for hls_dispose. // update the hls time, for hls_dispose.
last_update_time = srs_get_system_time(); last_update_time = srs_get_system_time();
SrsSharedPtrMessage* video = shared_video->copy();
SrsAutoFree(SrsSharedPtrMessage, video);
// ignore info frame, // ignore info frame,
// @see https://github.com/ossrs/srs/issues/288#issuecomment-69863909 // @see https://github.com/ossrs/srs/issues/288#issuecomment-69863909
srs_assert(format->video); srs_assert(format->video);
return rtp_h264_muxer->frame_to_packet(video, format); return rtp_h264_muxer->frame_to_packet(shared_video, format);
} }

7
trunk/src/app/srs_app_rtp.hpp
View file

@ -33,6 +33,7 @@
class SrsFormat; class SrsFormat;
class SrsSample; class SrsSample;
class SrsSharedPtrMessage; class SrsSharedPtrMessage;
class SrsRtpSharedPacket;
class SrsRequest; class SrsRequest;
class SrsOriginHub; class SrsOriginHub;
@ -65,9 +66,9 @@ public:
public: public:
srs_error_t frame_to_packet(SrsSharedPtrMessage* shared_video, SrsFormat* format); srs_error_t frame_to_packet(SrsSharedPtrMessage* shared_video, SrsFormat* format);
private: private:
srs_error_t packet_fu_a(SrsSharedPtrMessage* shared_frame, SrsFormat* format, SrsSample* sample, std::vector<SrsSample>& rtp_packet_vec); srs_error_t packet_fu_a(SrsSharedPtrMessage* shared_frame, SrsFormat* format, SrsSample* sample, std::vector<SrsRtpSharedPacket*>& rtp_packet_vec);
srs_error_t packet_single_nalu(SrsSharedPtrMessage* shared_frame, SrsFormat* format, SrsSample* sample, std::vector<SrsSample>& rtp_packet_vec); srs_error_t packet_single_nalu(SrsSharedPtrMessage* shared_frame, SrsFormat* format, SrsSample* sample, std::vector<SrsRtpSharedPacket*>& rtp_packet_vec);
srs_error_t packet_stap_a(const std::string &sps, const std::string& pps, SrsSharedPtrMessage* shared_frame, std::vector<SrsSample>& rtp_packet_vec); srs_error_t packet_stap_a(const std::string &sps, const std::string& pps, SrsSharedPtrMessage* shared_frame, std::vector<SrsRtpSharedPacket*>& rtp_packet_vec);
}; };
class SrsRtp class SrsRtp

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

@ -2300,7 +2300,7 @@ srs_error_t SrsSource::on_video_imp(SrsSharedPtrMessage* msg)
if ((err = hub->on_video(msg, is_sequence_header)) != srs_success) { if ((err = hub->on_video(msg, is_sequence_header)) != srs_success) {
return srs_error_wrap(err, "hub consume video"); return srs_error_wrap(err, "hub consume video");
} }
// copy to all consumer // copy to all consumer
if (!drop_for_reduce) { if (!drop_for_reduce) {
for (int i = 0; i < (int)consumers.size(); i++) { for (int i = 0; i < (int)consumers.size(); i++) {

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

@ -322,6 +322,7 @@
#define ERROR_BASE64_DECODE 4039 #define ERROR_BASE64_DECODE 4039
#define ERROR_HTTP_STREAM_EOF 4040 #define ERROR_HTTP_STREAM_EOF 4040
#define ERROR_RTC_PORT 4041 #define ERROR_RTC_PORT 4041
#define ERROR_RTP_PACKET_CREATE 4042
/////////////////////////////////////////////////////// ///////////////////////////////////////////////////////
// HTTP API error. // HTTP API error.

39
trunk/src/kernel/srs_kernel_flv.cpp
View file

@ -36,6 +36,7 @@ using namespace std;
#include <srs_kernel_error.hpp> #include <srs_kernel_error.hpp>
#include <srs_kernel_buffer.hpp> #include <srs_kernel_buffer.hpp>
#include <srs_kernel_file.hpp> #include <srs_kernel_file.hpp>
#include <srs_kernel_rtp.hpp>
#include <srs_kernel_codec.hpp> #include <srs_kernel_codec.hpp>
#include <srs_kernel_utility.hpp> #include <srs_kernel_utility.hpp>
#include <srs_core_mem_watch.hpp> #include <srs_core_mem_watch.hpp>
@ -203,8 +204,6 @@ SrsSharedPtrMessage::SrsSharedPtrPayload::SrsSharedPtrPayload()
{ {
payload = NULL; payload = NULL;
size = 0; size = 0;
rtp_fragments = NULL;
nb_rtp_fragments = 0;
shared_count = 0; shared_count = 0;
} }
@ -214,17 +213,9 @@ SrsSharedPtrMessage::SrsSharedPtrPayload::~SrsSharedPtrPayload()
srs_memory_unwatch(payload); srs_memory_unwatch(payload);
#endif #endif
srs_freepa(payload); srs_freepa(payload);
for (int i = 0; i < nb_rtp_fragments; ++i) {
srs_freepa(rtp_fragments[i].bytes);
}
if (rtp_fragments != NULL && nb_rtp_fragments > 0) {
srs_freepa(rtp_fragments);
}
} }
SrsSharedPtrMessage::SrsSharedPtrMessage() : timestamp(0), stream_id(0), size(0), payload(NULL), rtp_fragments(NULL), nb_rtp_fragments(0) SrsSharedPtrMessage::SrsSharedPtrMessage() : timestamp(0), stream_id(0), size(0), payload(NULL)
{ {
ptr = NULL; ptr = NULL;
} }
@ -238,6 +229,10 @@ SrsSharedPtrMessage::~SrsSharedPtrMessage()
ptr->shared_count--; ptr->shared_count--;
} }
} }
for (int i = 0; i < rtp_packets.size(); ++i) {
srs_freep(rtp_packets[i]);
}
} }
srs_error_t SrsSharedPtrMessage::create(SrsCommonMessage* msg) srs_error_t SrsSharedPtrMessage::create(SrsCommonMessage* msg)
@ -315,15 +310,6 @@ bool SrsSharedPtrMessage::check(int stream_id)
return false; return false;
} }
void SrsSharedPtrMessage::set_rtp_fragments(SrsSample* samples, int nb_samples)
{
ptr->rtp_fragments = samples;
ptr->nb_rtp_fragments = nb_samples;
rtp_fragments = samples;
nb_rtp_fragments = nb_samples;
}
bool SrsSharedPtrMessage::is_av() bool SrsSharedPtrMessage::is_av()
{ {
return ptr->header.message_type == RTMP_MSG_AudioMessage return ptr->header.message_type == RTMP_MSG_AudioMessage
@ -364,12 +350,19 @@ SrsSharedPtrMessage* SrsSharedPtrMessage::copy()
copy->stream_id = stream_id; copy->stream_id = stream_id;
copy->payload = ptr->payload; copy->payload = ptr->payload;
copy->size = ptr->size; copy->size = ptr->size;
copy->rtp_fragments = ptr->rtp_fragments;
copy->nb_rtp_fragments = ptr->nb_rtp_fragments; for (int i = 0; i < rtp_packets.size(); ++i) {
copy->rtp_packets.push_back(rtp_packets[i]->copy());
}
return copy; return copy;
} }
void SrsSharedPtrMessage::set_rtp_packets(const std::vector<SrsRtpSharedPacket*>& pkts)
{
rtp_packets = pkts;
}
SrsFlvTransmuxer::SrsFlvTransmuxer() SrsFlvTransmuxer::SrsFlvTransmuxer()
{ {
writer = NULL; writer = NULL;

11
trunk/src/kernel/srs_kernel_flv.hpp
View file

@ -27,6 +27,7 @@
#include <srs_core.hpp> #include <srs_core.hpp>
#include <string> #include <string>
#include <vector>
// For srs-librtmp, @see https://github.com/ossrs/srs/issues/213 // For srs-librtmp, @see https://github.com/ossrs/srs/issues/213
#ifndef _WIN32 #ifndef _WIN32
@ -39,6 +40,7 @@ class ISrsReader;
class SrsFileReader; class SrsFileReader;
class SrsPacket; class SrsPacket;
class SrsSample; class SrsSample;
class SrsRtpSharedPacket;
#define SRS_FLV_TAG_HEADER_SIZE 11 #define SRS_FLV_TAG_HEADER_SIZE 11
#define SRS_FLV_PREVIOUS_TAG_SIZE 4 #define SRS_FLV_PREVIOUS_TAG_SIZE 4
@ -287,8 +289,7 @@ public:
// video/audio packet use raw bytes, no video/audio packet. // video/audio packet use raw bytes, no video/audio packet.
char* payload; char* payload;
SrsSample* rtp_fragments; std::vector<SrsRtpSharedPacket*> rtp_packets;
int nb_rtp_fragments;
private: private:
class SrsSharedPtrPayload class SrsSharedPtrPayload
{ {
@ -302,8 +303,6 @@ private:
int size; int size;
// The reference count // The reference count
int shared_count; int shared_count;
SrsSample* rtp_fragments;
int nb_rtp_fragments;
public: public:
SrsSharedPtrPayload(); SrsSharedPtrPayload();
virtual ~SrsSharedPtrPayload(); virtual ~SrsSharedPtrPayload();
@ -333,8 +332,6 @@ public:
// check perfer cid and stream id. // check perfer cid and stream id.
// @return whether stream id already set. // @return whether stream id already set.
virtual bool check(int stream_id); virtual bool check(int stream_id);
virtual void set_rtp_fragments(SrsSample* samples, int nb_samples);
public: public:
virtual bool is_av(); virtual bool is_av();
virtual bool is_audio(); virtual bool is_audio();
@ -347,6 +344,8 @@ public:
// copy current shared ptr message, use ref-count. // copy current shared ptr message, use ref-count.
// @remark, assert object is created. // @remark, assert object is created.
virtual SrsSharedPtrMessage* copy(); virtual SrsSharedPtrMessage* copy();
public:
virtual void set_rtp_packets(const std::vector<SrsRtpSharedPacket*>& pkts);
}; };
// Transmux RTMP packets to FLV stream. // Transmux RTMP packets to FLV stream.