R3944Realms/srs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

AI: Replace SrsSharedPtrMessage with SrsMediaPacket for unified media packet handling. v7.0.74 (#4465)

Browse Source 
This PR introduces a major refactoring to replace `SrsSharedPtrMessage`
with `SrsMediaPacket` throughout the SRS codebase, providing a more
unified and cleaner approach to media packet handling.

---------

Co-authored-by: OSSRS-AI <winlinam@gmail.com>
This commit is contained in:
Winlin 2025-09-01 18:06:24 -04:00 committed by GitHub
parent c534a265e5
commit 3e8cb3f9d5
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
72 changed files with 3749 additions and 3942 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
trunk/configure vendored
View File

@ -251,7 +251,7 @@ 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_consts" "srs_kernel_aac" "srs_kernel_mp3" "srs_kernel_ts" "srs_kernel_ps"
"srs_kernel_stream" "srs_kernel_balance" "srs_kernel_mp4" "srs_kernel_file"
"srs_kernel_kbps" "srs_kernel_rtc_rtp" "srs_kernel_rtc_rtcp")
"srs_kernel_kbps" "srs_kernel_rtc_rtp" "srs_kernel_rtc_rtcp" "srs_kernel_packet")
KERNEL_INCS="src/kernel"; MODULE_DIR=${KERNEL_INCS} . $SRS_WORKDIR/auto/modules.sh
KERNEL_OBJS="${MODULE_OBJS[@]}"
#

1
trunk/doc/CHANGELOG.md
View File

@ -7,6 +7,7 @@ The changelog for SRS.
<a name="v7-changes"></a>
## SRS 7.0 Changelog
* v7.0, 2025-09-01, Merge [#4465](https://github.com/ossrs/srs/pull/4465): AI: Replace SrsSharedPtrMessage with SrsMediaPacket for unified media packet handling. v7.0.74 (#4465)
* v7.0, 2025-09-01, Merge [#4464](https://github.com/ossrs/srs/pull/4464): AI: Use shared ptr in RTMP message. v7.0.73 (#4464)
* v7.0, 2025-09-01, Merge [#4463](https://github.com/ossrs/srs/pull/4463): AI: Use SrsHttpUri for URL parsing and add legacy RTMP URL conversion. v7.0.72 (#4463)
* v7.0, 2025-09-01, Merge [#4462](https://github.com/ossrs/srs/pull/4462): HTTP: Rename HTTP hijack to dynamic match for better clarity. v7.0.71 (#4462)

8
trunk/src/app/srs_app_caster_flv.cpp
View File

@ -279,11 +279,15 @@ srs_error_t SrsDynamicHttpConn::do_proxy(ISrsHttpResponseReader *rr, SrsFlvDecod
return srs_error_wrap(err, "read tag data");
}
SrsSharedPtrMessage *msg = NULL;
if ((err = srs_rtmp_create_msg(type, time, data, size, sdk->sid(), &msg)) != srs_success) {
SrsCommonMessage *cmsg = NULL;
if ((err = srs_rtmp_create_msg(type, time, data, size, sdk->sid(), &cmsg)) != srs_success) {
return srs_error_wrap(err, "create message");
}
SrsMediaPacket *msg = new SrsMediaPacket();
cmsg->to_msg(msg);
srs_freep(cmsg);
// TODO: FIXME: for post flv, reconnect when error.
if ((err = sdk->send_and_free_message(msg)) != srs_success) {
return srs_error_wrap(err, "send message");

12
trunk/src/app/srs_app_dash.cpp
View File

@ -112,7 +112,7 @@ srs_error_t SrsFragmentedMp4::initialize(ISrsRequest *r, bool video, int64_t tim
return err;
}
srs_error_t SrsFragmentedMp4::write(SrsSharedPtrMessage *shared_msg, SrsFormat *format)
srs_error_t SrsFragmentedMp4::write(SrsMediaPacket *shared_msg, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -480,7 +480,7 @@ void SrsDashController::on_unpublish()
}
}
srs_error_t SrsDashController::on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format)
srs_error_t SrsDashController::on_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -552,7 +552,7 @@ srs_error_t SrsDashController::on_audio(SrsSharedPtrMessage *shared_audio, SrsFo
return err;
}
srs_error_t SrsDashController::on_video(SrsSharedPtrMessage *shared_video, SrsFormat *format)
srs_error_t SrsDashController::on_video(SrsMediaPacket *shared_video, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -641,7 +641,7 @@ srs_error_t SrsDashController::refresh_mpd(SrsFormat *format)
return err;
}
srs_error_t SrsDashController::refresh_init_mp4(SrsSharedPtrMessage *msg, SrsFormat *format)
srs_error_t SrsDashController::refresh_init_mp4(SrsMediaPacket *msg, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -796,7 +796,7 @@ srs_error_t SrsDash::on_publish()
return err;
}
srs_error_t SrsDash::on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format)
srs_error_t SrsDash::on_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -818,7 +818,7 @@ srs_error_t SrsDash::on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *form
return err;
}
srs_error_t SrsDash::on_video(SrsSharedPtrMessage *shared_video, SrsFormat *format)
srs_error_t SrsDash::on_video(SrsMediaPacket *shared_video, SrsFormat *format)
{
srs_error_t err = srs_success;

14
trunk/src/app/srs_app_dash.hpp
View File

@ -16,7 +16,7 @@
class ISrsRequest;
class SrsOriginHub;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsFormat;
class SrsFileWriter;
class SrsMpdWriter;
@ -54,7 +54,7 @@ public:
// Initialize the fragment, create the home dir, open the file.
virtual srs_error_t initialize(ISrsRequest *r, bool video, int64_t time, SrsMpdWriter *mpd, uint32_t tid);
// Write media message to fragment.
virtual srs_error_t write(SrsSharedPtrMessage *shared_msg, SrsFormat *format);
virtual srs_error_t write(SrsMediaPacket *shared_msg, SrsFormat *format);
// Reap the fragment, close the fd and rename tmp to official file.
virtual srs_error_t reap(uint64_t &dts);
};
@ -154,12 +154,12 @@ public:
virtual srs_error_t initialize(ISrsRequest *r);
virtual srs_error_t on_publish();
virtual void on_unpublish();
virtual srs_error_t on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format);
virtual srs_error_t on_video(SrsSharedPtrMessage *shared_video, SrsFormat *format);
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
virtual srs_error_t on_video(SrsMediaPacket *shared_video, SrsFormat *format);
private:
virtual srs_error_t refresh_mpd(SrsFormat *format);
virtual srs_error_t refresh_init_mp4(SrsSharedPtrMessage *msg, SrsFormat *format);
virtual srs_error_t refresh_init_mp4(SrsMediaPacket *msg, SrsFormat *format);
};
// The MPEG-DASH encoder, transmux RTMP to DASH.
@ -190,9 +190,9 @@ public:
// When stream start publishing.
virtual srs_error_t on_publish();
// When got an shared audio message.
virtual srs_error_t on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format);
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
// When got an shared video message.
virtual srs_error_t on_video(SrsSharedPtrMessage *shared_video, SrsFormat *format);
virtual srs_error_t on_video(SrsMediaPacket *shared_video, SrsFormat *format);
// When stream stop publishing.
virtual void on_unpublish();
};

42
trunk/src/app/srs_app_dvr.cpp
View File

@ -117,17 +117,17 @@ srs_error_t SrsDvrSegmenter::open()
return err;
}
srs_error_t SrsDvrSegmenter::write_metadata(SrsSharedPtrMessage *metadata)
srs_error_t SrsDvrSegmenter::write_metadata(SrsMediaPacket *metadata)
{
return encode_metadata(metadata);
}
srs_error_t SrsDvrSegmenter::write_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format)
srs_error_t SrsDvrSegmenter::write_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
{
srs_error_t err = srs_success;
// TODO: FIXME: Use SrsSharedPtr instead.
SrsUniquePtr<SrsSharedPtrMessage> audio(shared_audio->copy());
SrsUniquePtr<SrsMediaPacket> audio(shared_audio->copy());
if ((err = jitter->correct(audio.get(), jitter_algorithm)) != srs_success) {
return srs_error_wrap(err, "jitter");
@ -144,12 +144,12 @@ srs_error_t SrsDvrSegmenter::write_audio(SrsSharedPtrMessage *shared_audio, SrsF
return err;
}
srs_error_t SrsDvrSegmenter::write_video(SrsSharedPtrMessage *shared_video, SrsFormat *format)
srs_error_t SrsDvrSegmenter::write_video(SrsMediaPacket *shared_video, SrsFormat *format)
{
srs_error_t err = srs_success;
// TODO: FIXME: Use SrsSharedPtr instead.
SrsUniquePtr<SrsSharedPtrMessage> video(shared_video->copy());
SrsUniquePtr<SrsMediaPacket> video(shared_video->copy());
if ((err = jitter->correct(video.get(), jitter_algorithm)) != srs_success) {
return srs_error_wrap(err, "jitter");
@ -215,7 +215,7 @@ string SrsDvrSegmenter::generate_path()
return flv_path;
}
srs_error_t SrsDvrSegmenter::on_update_duration(SrsSharedPtrMessage *msg)
srs_error_t SrsDvrSegmenter::on_update_duration(SrsMediaPacket *msg)
{
fragment->append(msg->timestamp);
return srs_success;
@ -310,7 +310,7 @@ srs_error_t SrsDvrFlvSegmenter::open_encoder()
return err;
}
srs_error_t SrsDvrFlvSegmenter::encode_metadata(SrsSharedPtrMessage *metadata)
srs_error_t SrsDvrFlvSegmenter::encode_metadata(SrsMediaPacket *metadata)
{
srs_error_t err = srs_success;
@ -366,7 +366,7 @@ srs_error_t SrsDvrFlvSegmenter::encode_metadata(SrsSharedPtrMessage *metadata)
return err;
}
srs_error_t SrsDvrFlvSegmenter::encode_audio(SrsSharedPtrMessage *audio, SrsFormat *format)
srs_error_t SrsDvrFlvSegmenter::encode_audio(SrsMediaPacket *audio, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -379,7 +379,7 @@ srs_error_t SrsDvrFlvSegmenter::encode_audio(SrsSharedPtrMessage *audio, SrsForm
return err;
}
srs_error_t SrsDvrFlvSegmenter::encode_video(SrsSharedPtrMessage *video, SrsFormat *format)
srs_error_t SrsDvrFlvSegmenter::encode_video(SrsMediaPacket *video, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -439,12 +439,12 @@ srs_error_t SrsDvrMp4Segmenter::open_encoder()
return err;
}
srs_error_t SrsDvrMp4Segmenter::encode_metadata(SrsSharedPtrMessage * /*metadata*/)
srs_error_t SrsDvrMp4Segmenter::encode_metadata(SrsMediaPacket * /*metadata*/)
{
return srs_success;
}
srs_error_t SrsDvrMp4Segmenter::encode_audio(SrsSharedPtrMessage *audio, SrsFormat *format)
srs_error_t SrsDvrMp4Segmenter::encode_audio(SrsMediaPacket *audio, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -472,7 +472,7 @@ srs_error_t SrsDvrMp4Segmenter::encode_audio(SrsSharedPtrMessage *audio, SrsForm
return err;
}
srs_error_t SrsDvrMp4Segmenter::encode_video(SrsSharedPtrMessage *video, SrsFormat *format)
srs_error_t SrsDvrMp4Segmenter::encode_video(SrsMediaPacket *video, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -607,7 +607,7 @@ void SrsDvrPlan::on_unpublish()
{
}
srs_error_t SrsDvrPlan::on_meta_data(SrsSharedPtrMessage *shared_metadata)
srs_error_t SrsDvrPlan::on_meta_data(SrsMediaPacket *shared_metadata)
{
srs_error_t err = srs_success;
@ -618,7 +618,7 @@ srs_error_t SrsDvrPlan::on_meta_data(SrsSharedPtrMessage *shared_metadata)
return segment->write_metadata(shared_metadata);
}
srs_error_t SrsDvrPlan::on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format)
srs_error_t SrsDvrPlan::on_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -633,7 +633,7 @@ srs_error_t SrsDvrPlan::on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *f
return err;
}
srs_error_t SrsDvrPlan::on_video(SrsSharedPtrMessage *shared_video, SrsFormat *format)
srs_error_t SrsDvrPlan::on_video(SrsMediaPacket *shared_video, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -816,7 +816,7 @@ void SrsDvrSegmentPlan::on_unpublish()
SrsDvrPlan::on_unpublish();
}
srs_error_t SrsDvrSegmentPlan::on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format)
srs_error_t SrsDvrSegmentPlan::on_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -831,7 +831,7 @@ srs_error_t SrsDvrSegmentPlan::on_audio(SrsSharedPtrMessage *shared_audio, SrsFo
return err;
}
srs_error_t SrsDvrSegmentPlan::on_video(SrsSharedPtrMessage *shared_video, SrsFormat *format)
srs_error_t SrsDvrSegmentPlan::on_video(SrsMediaPacket *shared_video, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -846,7 +846,7 @@ srs_error_t SrsDvrSegmentPlan::on_video(SrsSharedPtrMessage *shared_video, SrsFo
return err;
}
srs_error_t SrsDvrSegmentPlan::update_duration(SrsSharedPtrMessage *msg)
srs_error_t SrsDvrSegmentPlan::update_duration(SrsMediaPacket *msg)
{
srs_error_t err = srs_success;
@ -981,7 +981,7 @@ void SrsDvr::on_unpublish()
plan->on_unpublish();
}
srs_error_t SrsDvr::on_meta_data(SrsSharedPtrMessage *metadata)
srs_error_t SrsDvr::on_meta_data(SrsMediaPacket *metadata)
{
srs_error_t err = srs_success;
@ -997,7 +997,7 @@ srs_error_t SrsDvr::on_meta_data(SrsSharedPtrMessage *metadata)
return err;
}
srs_error_t SrsDvr::on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format)
srs_error_t SrsDvr::on_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
{
// the dvr for this stream is not actived.
if (!actived) {
@ -1007,7 +1007,7 @@ srs_error_t SrsDvr::on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *forma
return plan->on_audio(shared_audio, format);
}
srs_error_t SrsDvr::on_video(SrsSharedPtrMessage *shared_video, SrsFormat *format)
srs_error_t SrsDvr::on_video(SrsMediaPacket *shared_video, SrsFormat *format)
{
// the dvr for this stream is not actived.
if (!actived) {

46
trunk/src/app/srs_app_dvr.hpp
View File

@ -17,7 +17,7 @@ class SrsOriginHub;
class ISrsRequest;
class SrsBuffer;
class SrsRtmpJitter;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsFileWriter;
class SrsFlvTransmuxer;
class SrsDvrPlan;
@ -65,13 +65,13 @@ public:
// @remark Ignore when file is already open.
virtual srs_error_t open();
// Write the metadata.
virtual srs_error_t write_metadata(SrsSharedPtrMessage *metadata);
virtual srs_error_t write_metadata(SrsMediaPacket *metadata);
// Write audio packet.
// @param shared_audio, directly ptr, copy it if need to save it.
virtual srs_error_t write_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format);
virtual srs_error_t write_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
// Write video packet.
// @param shared_video, directly ptr, copy it if need to save it.
virtual srs_error_t write_video(SrsSharedPtrMessage *shared_video, SrsFormat *format);
virtual srs_error_t write_video(SrsMediaPacket *shared_video, SrsFormat *format);
// Refresh the metadata. For example, there is duration in flv metadata,
// when DVR in append mode, the duration must be update every some seconds.
// @remark Maybe ignored by concreate segmenter.
@ -82,16 +82,16 @@ public:
protected:
virtual srs_error_t open_encoder() = 0;
virtual srs_error_t encode_metadata(SrsSharedPtrMessage *metadata) = 0;
virtual srs_error_t encode_audio(SrsSharedPtrMessage *audio, SrsFormat *format) = 0;
virtual srs_error_t encode_video(SrsSharedPtrMessage *video, SrsFormat *format) = 0;
virtual srs_error_t encode_metadata(SrsMediaPacket *metadata) = 0;
virtual srs_error_t encode_audio(SrsMediaPacket *audio, SrsFormat *format) = 0;
virtual srs_error_t encode_video(SrsMediaPacket *video, SrsFormat *format) = 0;
virtual srs_error_t close_encoder() = 0;
private:
// Generate the flv segment path.
virtual std::string generate_path();
// When update the duration of segment by rtmp msg.
virtual srs_error_t on_update_duration(SrsSharedPtrMessage *msg);
virtual srs_error_t on_update_duration(SrsMediaPacket *msg);
};
// The FLV segmenter to use FLV encoder to write file.
@ -120,9 +120,9 @@ public:
protected:
virtual srs_error_t open_encoder();
virtual srs_error_t encode_metadata(SrsSharedPtrMessage *metadata);
virtual srs_error_t encode_audio(SrsSharedPtrMessage *audio, SrsFormat *format);
virtual srs_error_t encode_video(SrsSharedPtrMessage *video, SrsFormat *format);
virtual srs_error_t encode_metadata(SrsMediaPacket *metadata);
virtual srs_error_t encode_audio(SrsMediaPacket *audio, SrsFormat *format);
virtual srs_error_t encode_video(SrsMediaPacket *video, SrsFormat *format);
virtual srs_error_t close_encoder();
};
@ -142,9 +142,9 @@ public:
protected:
virtual srs_error_t open_encoder();
virtual srs_error_t encode_metadata(SrsSharedPtrMessage *metadata);
virtual srs_error_t encode_audio(SrsSharedPtrMessage *audio, SrsFormat *format);
virtual srs_error_t encode_video(SrsSharedPtrMessage *video, SrsFormat *format);
virtual srs_error_t encode_metadata(SrsMediaPacket *metadata);
virtual srs_error_t encode_audio(SrsMediaPacket *audio, SrsFormat *format);
virtual srs_error_t encode_video(SrsMediaPacket *video, SrsFormat *format);
virtual srs_error_t close_encoder();
};
@ -184,9 +184,9 @@ public:
virtual srs_error_t initialize(SrsOriginHub *h, SrsDvrSegmenter *s, ISrsRequest *r);
virtual srs_error_t on_publish(ISrsRequest *r);
virtual void on_unpublish();
virtual srs_error_t on_meta_data(SrsSharedPtrMessage *shared_metadata);
virtual srs_error_t on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format);
virtual srs_error_t on_video(SrsSharedPtrMessage *shared_video, SrsFormat *format);
virtual srs_error_t on_meta_data(SrsMediaPacket *shared_metadata);
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
virtual srs_error_t on_video(SrsMediaPacket *shared_video, SrsFormat *format);
// Internal interface for segmenter.
public:
// When segmenter close a segment.
@ -226,11 +226,11 @@ public:
virtual srs_error_t initialize(SrsOriginHub *h, SrsDvrSegmenter *s, ISrsRequest *r);
virtual srs_error_t on_publish(ISrsRequest *r);
virtual void on_unpublish();
virtual srs_error_t on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format);
virtual srs_error_t on_video(SrsSharedPtrMessage *shared_video, SrsFormat *format);
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
virtual srs_error_t on_video(SrsMediaPacket *shared_video, SrsFormat *format);
private:
virtual srs_error_t update_duration(SrsSharedPtrMessage *msg);
virtual srs_error_t update_duration(SrsMediaPacket *msg);
};
// DVR(Digital Video Recorder) to record RTMP stream to flv/mp4 file.
@ -264,13 +264,13 @@ public:
// when encoder stop(unpublish) to publish RTMP stream.
virtual void on_unpublish();
// get some information from metadata, it's optinal.
virtual srs_error_t on_meta_data(SrsSharedPtrMessage *metadata);
virtual srs_error_t on_meta_data(SrsMediaPacket *metadata);
// mux the audio packets to dvr.
// @param shared_audio, directly ptr, copy it if need to save it.
virtual srs_error_t on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *foramt);
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio, SrsFormat *foramt);
// mux the video packets to dvr.
// @param shared_video, directly ptr, copy it if need to save it.
virtual srs_error_t on_video(SrsSharedPtrMessage *shared_video, SrsFormat *format);
virtual srs_error_t on_video(SrsMediaPacket *shared_video, SrsFormat *format);
};
extern SrsAsyncCallWorker *_srs_dvr_async;

20
trunk/src/app/srs_app_edge.cpp
View File

@ -130,7 +130,7 @@ srs_error_t SrsEdgeRtmpUpstream::recv_message(SrsCommonMessage **pmsg)
return sdk->recv_message(pmsg);
}
srs_error_t SrsEdgeRtmpUpstream::decode_message(SrsCommonMessage *msg, SrsPacket **ppacket)
srs_error_t SrsEdgeRtmpUpstream::decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket)
{
return sdk->decode_message(msg, ppacket);
}
@ -333,11 +333,11 @@ srs_error_t SrsEdgeFlvUpstream::recv_message(SrsCommonMessage **pmsg)
return err;
}
srs_error_t SrsEdgeFlvUpstream::decode_message(SrsCommonMessage *msg, SrsPacket **ppacket)
srs_error_t SrsEdgeFlvUpstream::decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket)
{
srs_error_t err = srs_success;
SrsPacket *packet = NULL;
SrsRtmpCommand *packet = NULL;
SrsBuffer stream(msg->payload(), msg->size());
SrsMessageHeader &header = msg->header;
@ -647,11 +647,11 @@ srs_error_t SrsEdgeIngester::process_publish_message(SrsCommonMessage *msg, stri
// process onMetaData
if (msg->header.is_amf0_data() || msg->header.is_amf3_data()) {
SrsPacket *pkt_raw = NULL;
SrsRtmpCommand *pkt_raw = NULL;
if ((err = upstream->decode_message(msg, &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "decode message");
}
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
SrsUniquePtr<SrsRtmpCommand> pkt(pkt_raw);
if (dynamic_cast<SrsOnMetaDataPacket *>(pkt.get())) {
SrsOnMetaDataPacket *metadata = dynamic_cast<SrsOnMetaDataPacket *>(pkt.get());
@ -666,11 +666,11 @@ srs_error_t SrsEdgeIngester::process_publish_message(SrsCommonMessage *msg, stri
// call messages, for example, reject, redirect.
if (msg->header.is_amf0_command() || msg->header.is_amf3_command()) {
SrsPacket *pkt_raw = NULL;
SrsRtmpCommand *pkt_raw = NULL;
if ((err = upstream->decode_message(msg, &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "decode message");
}
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
SrsUniquePtr<SrsRtmpCommand> pkt(pkt_raw);
// RTMP 302 redirect
if (dynamic_cast<SrsCallPacket *>(pkt.get())) {
@ -928,10 +928,8 @@ srs_error_t SrsEdgeForwarder::proxy(SrsCommonMessage *msg)
return err;
}
SrsSharedPtrMessage copy;
if ((err = copy.create(msg)) != srs_success) {
return srs_error_wrap(err, "create message");
}
SrsMediaPacket copy;
msg->to_msg(&copy);
copy.stream_id = sdk->sid();
if ((err = queue->enqueue(copy.copy())) != srs_success) {

8
trunk/src/app/srs_app_edge.hpp
View File

@ -28,7 +28,7 @@ class SrsKbps;
class SrsLbRoundRobin;
class SrsTcpClient;
class SrsSimpleRtmpClient;
class SrsPacket;
class SrsRtmpCommand;
class SrsHttpClient;
class ISrsHttpMessage;
class SrsHttpFileReader;
@ -66,7 +66,7 @@ public:
public:
virtual srs_error_t connect(ISrsRequest *r, SrsLbRoundRobin *lb) = 0;
virtual srs_error_t recv_message(SrsCommonMessage **pmsg) = 0;
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsPacket **ppacket) = 0;
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket) = 0;
virtual void close() = 0;
public:
@ -96,7 +96,7 @@ public:
public:
virtual srs_error_t connect(ISrsRequest *r, SrsLbRoundRobin *lb);
virtual srs_error_t recv_message(SrsCommonMessage **pmsg);
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsPacket **ppacket);
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket);
virtual void close();
public:
@ -135,7 +135,7 @@ private:
public:
virtual srs_error_t recv_message(SrsCommonMessage **pmsg);
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsPacket **ppacket);
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket);
virtual void close();
public:

12
trunk/src/app/srs_app_forward.cpp
View File

@ -98,11 +98,11 @@ void SrsForwarder::on_unpublish()
sdk->close();
}
srs_error_t SrsForwarder::on_meta_data(SrsSharedPtrMessage *shared_metadata)
srs_error_t SrsForwarder::on_meta_data(SrsMediaPacket *shared_metadata)
{
srs_error_t err = srs_success;
SrsSharedPtrMessage *metadata = shared_metadata->copy();
SrsMediaPacket *metadata = shared_metadata->copy();
// TODO: FIXME: config the jitter of Forwarder.
if ((err = jitter->correct(metadata, SrsRtmpJitterAlgorithmOFF)) != srs_success) {
@ -116,11 +116,11 @@ srs_error_t SrsForwarder::on_meta_data(SrsSharedPtrMessage *shared_metadata)
return err;
}
srs_error_t SrsForwarder::on_audio(SrsSharedPtrMessage *shared_audio)
srs_error_t SrsForwarder::on_audio(SrsMediaPacket *shared_audio)
{
srs_error_t err = srs_success;
SrsSharedPtrMessage *msg = shared_audio->copy();
SrsMediaPacket *msg = shared_audio->copy();
// TODO: FIXME: config the jitter of Forwarder.
if ((err = jitter->correct(msg, SrsRtmpJitterAlgorithmOFF)) != srs_success) {
@ -139,11 +139,11 @@ srs_error_t SrsForwarder::on_audio(SrsSharedPtrMessage *shared_audio)
return err;
}
srs_error_t SrsForwarder::on_video(SrsSharedPtrMessage *shared_video)
srs_error_t SrsForwarder::on_video(SrsMediaPacket *shared_video)
{
srs_error_t err = srs_success;
SrsSharedPtrMessage *msg = shared_video->copy();
SrsMediaPacket *msg = shared_video->copy();
// TODO: FIXME: config the jitter of Forwarder.
if ((err = jitter->correct(msg, SrsRtmpJitterAlgorithmOFF)) != srs_success) {

12
trunk/src/app/srs_app_forward.hpp
View File

@ -14,7 +14,7 @@
#include <srs_app_st.hpp>
class ISrsProtocolReadWriter;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsOnMetaDataPacket;
class SrsMessageQueue;
class SrsRtmpJitter;
@ -46,8 +46,8 @@ private:
SrsRtmpJitter *jitter;
SrsMessageQueue *queue;
// Cache the sequence header for retry when slave is failed.
SrsSharedPtrMessage *sh_audio;
SrsSharedPtrMessage *sh_video;
SrsMediaPacket *sh_audio;
SrsMediaPacket *sh_video;
public:
SrsForwarder(SrsOriginHub *h);
@ -62,13 +62,13 @@ public:
virtual void on_unpublish();
// Forward the audio packet.
// @param shared_metadata, directly ptr, copy it if need to save it.
virtual srs_error_t on_meta_data(SrsSharedPtrMessage *shared_metadata);
virtual srs_error_t on_meta_data(SrsMediaPacket *shared_metadata);
// Forward the audio packet.
// @param shared_audio, directly ptr, copy it if need to save it.
virtual srs_error_t on_audio(SrsSharedPtrMessage *shared_audio);
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio);
// Forward the video packet.
// @param shared_video, directly ptr, copy it if need to save it.
virtual srs_error_t on_video(SrsSharedPtrMessage *shared_video);
virtual srs_error_t on_video(SrsMediaPacket *shared_video);
// Interface ISrsReusableThread2Handler.
public:
virtual srs_error_t cycle();

22
trunk/src/app/srs_app_gb28181.cpp
View File

@ -1547,15 +1547,15 @@ SrsMpegpsQueue::SrsMpegpsQueue()
SrsMpegpsQueue::~SrsMpegpsQueue()
{
std::map<int64_t, SrsSharedPtrMessage *>::iterator it;
std::map<int64_t, SrsMediaPacket *>::iterator it;
for (it = msgs.begin(); it != msgs.end(); ++it) {
SrsSharedPtrMessage *msg = it->second;
SrsMediaPacket *msg = it->second;
srs_freep(msg);
}
msgs.clear();
}
srs_error_t SrsMpegpsQueue::push(SrsSharedPtrMessage *msg)
srs_error_t SrsMpegpsQueue::push(SrsMediaPacket *msg)
{
srs_error_t err = srs_success;
@ -1588,7 +1588,7 @@ srs_error_t SrsMpegpsQueue::push(SrsSharedPtrMessage *msg)
return err;
}
SrsSharedPtrMessage *SrsMpegpsQueue::dequeue()
SrsMediaPacket *SrsMpegpsQueue::dequeue()
{
// got 2+ videos and audios, ok to dequeue.
bool av_ok = nb_videos >= 2 && nb_audios >= 2;
@ -1596,8 +1596,8 @@ SrsSharedPtrMessage *SrsMpegpsQueue::dequeue()
bool av_overflow = nb_videos > 100 || nb_audios > 300;
if (av_ok || av_overflow) {
std::map<int64_t, SrsSharedPtrMessage *>::iterator it = msgs.begin();
SrsSharedPtrMessage *msg = it->second;
std::map<int64_t, SrsMediaPacket *>::iterator it = msgs.begin();
SrsMediaPacket *msg = it->second;
msgs.erase(it);
if (msg->is_audio()) {
@ -2107,12 +2107,14 @@ srs_error_t SrsGbMuxer::rtmp_write_packet(char type, uint32_t timestamp, char *d
return srs_error_wrap(err, "connect");
}
SrsSharedPtrMessage *msg = NULL;
if ((err = srs_rtmp_create_msg(type, timestamp, data, size, sdk_->sid(), &msg)) != srs_success) {
SrsCommonMessage *cmsg = NULL;
if ((err = srs_rtmp_create_msg(type, timestamp, data, size, sdk_->sid(), &cmsg)) != srs_success) {
return srs_error_wrap(err, "create message");
}
srs_assert(msg);
SrsMediaPacket *msg = new SrsMediaPacket();
cmsg->to_msg(msg);
srs_freep(cmsg);
// push msg to queue.
if ((err = queue_->push(msg)) != srs_success) {

8
trunk/src/app/srs_app_gb28181.hpp
View File

@ -37,7 +37,7 @@ class SrsSimpleRtmpClient;
struct SrsRawAacStreamCodec;
class SrsRawH264Stream;
class SrsRawHEVCStream;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsPithyPrint;
class SrsRawAacStream;
class ISrsHttpServeMux;
@ -485,7 +485,7 @@ class SrsMpegpsQueue
{
private:
// The key: dts, value: msg.
std::map<int64_t, SrsSharedPtrMessage *> msgs;
std::map<int64_t, SrsMediaPacket *> msgs;
int nb_audios;
int nb_videos;
@ -494,8 +494,8 @@ public:
virtual ~SrsMpegpsQueue();
public:
virtual srs_error_t push(SrsSharedPtrMessage *msg);
virtual SrsSharedPtrMessage *dequeue();
virtual srs_error_t push(SrsMediaPacket *msg);
virtual SrsMediaPacket *dequeue();
};
// Mux GB28181 to RTMP.

36
trunk/src/app/srs_app_hds.cpp
View File

@ -38,7 +38,7 @@ char flv_header[] = {'F', 'L', 'V',
0x01, 0x05, 0x00, 0x00, 0x00, 0x09,
0x00, 0x00, 0x00, 0x00};
string serialFlv(SrsSharedPtrMessage *msg)
string serialFlv(SrsMediaPacket *msg)
{
int size = 15 + msg->size();
char *byte = new char[size];
@ -81,22 +81,22 @@ public:
srs_freep(audioSh);
// clean msgs
list<SrsSharedPtrMessage *>::iterator iter;
list<SrsMediaPacket *>::iterator iter;
for (iter = msgs.begin(); iter != msgs.end(); ++iter) {
SrsSharedPtrMessage *msg = *iter;
SrsMediaPacket *msg = *iter;
srs_freep(msg);
}
}
void on_video(SrsSharedPtrMessage *msg)
void on_video(SrsMediaPacket *msg)
{
SrsSharedPtrMessage *_msg = msg->copy();
SrsMediaPacket *_msg = msg->copy();
msgs.push_back(_msg);
}
void on_audio(SrsSharedPtrMessage *msg)
void on_audio(SrsMediaPacket *msg)
{
SrsSharedPtrMessage *_msg = msg->copy();
SrsMediaPacket *_msg = msg->copy();
msgs.push_back(_msg);
}
@ -116,9 +116,9 @@ public:
data.append(serialFlv(audioSh));
}
list<SrsSharedPtrMessage *>::iterator iter;
list<SrsMediaPacket *>::iterator iter;
for (iter = msgs.begin(); iter != msgs.end(); ++iter) {
SrsSharedPtrMessage *msg = *iter;
SrsMediaPacket *msg = *iter;
data.append(serialFlv(msg));
}
@ -158,10 +158,10 @@ public:
long long last_msg_ts = 0;
if (msgs.size() >= 2) {
SrsSharedPtrMessage *first_msg = msgs.front();
SrsMediaPacket *first_msg = msgs.front();
first_msg_ts = first_msg->timestamp;
SrsSharedPtrMessage *last_msg = msgs.back();
SrsMediaPacket *last_msg = msgs.back();
last_msg_ts = last_msg->timestamp;
duration_ms = (int)(last_msg_ts - first_msg_ts);
@ -200,13 +200,13 @@ public:
return start_time;
}
void set_video_sh(SrsSharedPtrMessage *msg)
void set_video_sh(SrsMediaPacket *msg)
{
srs_freep(videoSh);
videoSh = msg->copy();
}
void set_audio_sh(SrsSharedPtrMessage *msg)
void set_audio_sh(SrsMediaPacket *msg)
{
srs_freep(audioSh);
audioSh = msg->copy();
@ -219,7 +219,7 @@ public:
private:
ISrsRequest *req;
list<SrsSharedPtrMessage *> msgs;
list<SrsMediaPacket *> msgs;
/*!
the index of this fragment
@ -227,8 +227,8 @@ private:
int index;
long long start_time;
SrsSharedPtrMessage *videoSh;
SrsSharedPtrMessage *audioSh;
SrsMediaPacket *videoSh;
SrsMediaPacket *audioSh;
string path;
};
@ -290,7 +290,7 @@ srs_error_t SrsHds::on_unpublish()
return err;
}
srs_error_t SrsHds::on_video(SrsSharedPtrMessage *msg)
srs_error_t SrsHds::on_video(SrsMediaPacket *msg)
{
srs_error_t err = srs_success;
@ -340,7 +340,7 @@ srs_error_t SrsHds::on_video(SrsSharedPtrMessage *msg)
return err;
}
srs_error_t SrsHds::on_audio(SrsSharedPtrMessage *msg)
srs_error_t SrsHds::on_audio(SrsMediaPacket *msg)
{
srs_error_t err = srs_success;

10
trunk/src/app/srs_app_hds.hpp
View File

@ -14,7 +14,7 @@
#include <list>
class ISrsRequest;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsHdsFragment;
class SrsLiveSource;
@ -28,8 +28,8 @@ public:
srs_error_t on_publish(ISrsRequest *req);
srs_error_t on_unpublish();
srs_error_t on_video(SrsSharedPtrMessage *msg);
srs_error_t on_audio(SrsSharedPtrMessage *msg);
srs_error_t on_video(SrsMediaPacket *msg);
srs_error_t on_audio(SrsMediaPacket *msg);
private:
srs_error_t flush_mainfest();
@ -40,8 +40,8 @@ private:
std::list<SrsHdsFragment *> fragments;
SrsHdsFragment *currentSegment;
int fragment_index;
SrsSharedPtrMessage *video_sh;
SrsSharedPtrMessage *audio_sh;
SrsMediaPacket *video_sh;
SrsMediaPacket *audio_sh;
ISrsRequest *hds_req;
bool hds_enabled;

34
trunk/src/app/srs_app_hls.cpp
View File

@ -203,7 +203,7 @@ void SrsHlsM4sSegment::config_cipher(unsigned char *key, unsigned char *iv)
memcpy(this->iv, iv, 16);
}
srs_error_t SrsHlsM4sSegment::write(SrsSharedPtrMessage *shared_msg, SrsFormat *format)
srs_error_t SrsHlsM4sSegment::write(SrsMediaPacket *shared_msg, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -580,7 +580,7 @@ srs_error_t SrsHlsFmp4Muxer::write_init_mp4(SrsFormat *format, bool has_video, b
return err;
}
srs_error_t SrsHlsFmp4Muxer::write_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format)
srs_error_t SrsHlsFmp4Muxer::write_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -604,7 +604,7 @@ srs_error_t SrsHlsFmp4Muxer::write_audio(SrsSharedPtrMessage *shared_audio, SrsF
return err;
}
srs_error_t SrsHlsFmp4Muxer::write_video(SrsSharedPtrMessage *shared_video, SrsFormat *format)
srs_error_t SrsHlsFmp4Muxer::write_video(SrsMediaPacket *shared_video, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -2039,7 +2039,7 @@ srs_error_t SrsHlsController::on_unpublish()
return err;
}
srs_error_t SrsHlsController::on_sequence_header(SrsSharedPtrMessage *msg, SrsFormat *format)
srs_error_t SrsHlsController::on_sequence_header(SrsMediaPacket *msg, SrsFormat *format)
{
// TODO: support discontinuity for the same stream
// currently we reap and insert discontinity when encoder republish,
@ -2050,10 +2050,10 @@ srs_error_t SrsHlsController::on_sequence_header(SrsSharedPtrMessage *msg, SrsFo
return muxer->on_sequence_header();
}
srs_error_t SrsHlsController::write_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format)
srs_error_t SrsHlsController::write_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
{
srs_error_t err = srs_success;
SrsAudioFrame *frame = format->audio;
SrsParsedAudioPacket *frame = format->audio;
// Reset the aac samples counter when DTS jitter.
if (previous_audio_dts > shared_audio->timestamp) {
@ -2140,10 +2140,10 @@ srs_error_t SrsHlsController::write_audio(SrsSharedPtrMessage *shared_audio, Srs
return err;
}
srs_error_t SrsHlsController::write_video(SrsSharedPtrMessage *shared_video, SrsFormat *format)
srs_error_t SrsHlsController::write_video(SrsMediaPacket *shared_video, SrsFormat *format)
{
srs_error_t err = srs_success;
SrsVideoFrame *frame = format->video;
SrsParsedVideoPacket *frame = format->video;
int64_t dts = shared_video->timestamp * 90;
// Refresh the codec ASAP.
@ -2306,10 +2306,10 @@ srs_error_t SrsHlsMp4Controller::on_unpublish()
return err;
}
srs_error_t SrsHlsMp4Controller::write_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format)
srs_error_t SrsHlsMp4Controller::write_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
{
srs_error_t err = srs_success;
SrsAudioFrame *frame = format->audio;
SrsParsedAudioPacket *frame = format->audio;
// Ignore audio sequence header
if (format->is_aac_sequence_header() || format->is_mp3_sequence_header()) {
@ -2332,10 +2332,10 @@ srs_error_t SrsHlsMp4Controller::write_audio(SrsSharedPtrMessage *shared_audio,
return err;
}
srs_error_t SrsHlsMp4Controller::write_video(SrsSharedPtrMessage *shared_video, SrsFormat *format)
srs_error_t SrsHlsMp4Controller::write_video(SrsMediaPacket *shared_video, SrsFormat *format)
{
srs_error_t err = srs_success;
SrsVideoFrame *frame = format->video;
SrsParsedVideoPacket *frame = format->video;
// Refresh the codec ASAP.
if (muxer_->latest_vcodec() != frame->vcodec()->id) {
@ -2353,7 +2353,7 @@ srs_error_t SrsHlsMp4Controller::write_video(SrsSharedPtrMessage *shared_video,
return err;
}
srs_error_t SrsHlsMp4Controller::on_sequence_header(SrsSharedPtrMessage *msg, SrsFormat *format)
srs_error_t SrsHlsMp4Controller::on_sequence_header(SrsMediaPacket *msg, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -2622,7 +2622,7 @@ void SrsHls::on_unpublish()
unpublishing_ = false;
}
srs_error_t SrsHls::on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format)
srs_error_t SrsHls::on_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -2642,7 +2642,7 @@ srs_error_t SrsHls::on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *forma
// update the hls time, for hls_dispose.
last_update_time = srs_time_now_cached();
SrsUniquePtr<SrsSharedPtrMessage> audio(shared_audio->copy());
SrsUniquePtr<SrsMediaPacket> audio(shared_audio->copy());
// ts support audio codec: aac/mp3
SrsAudioCodecId acodec = format->acodec->id;
@ -2669,7 +2669,7 @@ srs_error_t SrsHls::on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *forma
return err;
}
srs_error_t SrsHls::on_video(SrsSharedPtrMessage *shared_video, SrsFormat *format)
srs_error_t SrsHls::on_video(SrsMediaPacket *shared_video, SrsFormat *format)
{
srs_error_t err = srs_success;
@ -2688,7 +2688,7 @@ srs_error_t SrsHls::on_video(SrsSharedPtrMessage *shared_video, SrsFormat *forma
// update the hls time, for hls_dispose.
last_update_time = srs_time_now_cached();
SrsUniquePtr<SrsSharedPtrMessage> video(shared_video->copy());
SrsUniquePtr<SrsMediaPacket> video(shared_video->copy());
// ignore info frame,
// @see https://github.com/ossrs/srs/issues/288#issuecomment-69863909

30
trunk/src/app/srs_app_hls.hpp
View File

@ -19,7 +19,7 @@
#include <srs_kernel_mp4.hpp>
class SrsFormat;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsAmf0Object;
class SrsRtmpJitter;
class SrsTsContextWriter;
@ -117,7 +117,7 @@ public:
public:
virtual srs_error_t initialize(int64_t time, uint32_t v_tid, uint32_t a_tid, int sequence_number, std::string m4s_path);
virtual void config_cipher(unsigned char *key, unsigned char *iv);
virtual srs_error_t write(SrsSharedPtrMessage *shared_msg, SrsFormat *format);
virtual srs_error_t write(SrsMediaPacket *shared_msg, SrsFormat *format);
// Finalizes segment
virtual srs_error_t reap(uint64_t dts);
};
@ -410,8 +410,8 @@ public:
public:
virtual srs_error_t write_init_mp4(SrsFormat *format, bool has_video, bool has_audio);
virtual srs_error_t write_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format);
virtual srs_error_t write_video(SrsSharedPtrMessage *shared_video, SrsFormat *format);
virtual srs_error_t write_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
virtual srs_error_t write_video(SrsMediaPacket *shared_video, SrsFormat *format);
public:
virtual srs_error_t on_unpublish();
@ -459,11 +459,11 @@ public:
virtual srs_error_t on_unpublish() = 0;
public:
virtual srs_error_t write_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format) = 0;
virtual srs_error_t write_video(SrsSharedPtrMessage *shared_video, SrsFormat *format) = 0;
virtual srs_error_t write_audio(SrsMediaPacket *shared_audio, SrsFormat *format) = 0;
virtual srs_error_t write_video(SrsMediaPacket *shared_video, SrsFormat *format) = 0;
public:
virtual srs_error_t on_sequence_header(SrsSharedPtrMessage *msg, SrsFormat *format) = 0;
virtual srs_error_t on_sequence_header(SrsMediaPacket *msg, SrsFormat *format) = 0;
virtual int sequence_no() = 0;
// TODO: maybe rename to segment_url?
virtual std::string ts_url() = 0;
@ -524,11 +524,11 @@ public:
// must write a #EXT-X-DISCONTINUITY to m3u8.
// @see: hls-m3u8-draft-pantos-http-live-streaming-12.txt
// @see: 3.4.11. EXT-X-DISCONTINUITY
virtual srs_error_t on_sequence_header(SrsSharedPtrMessage *shared_audio, SrsFormat *format);
virtual srs_error_t on_sequence_header(SrsMediaPacket *shared_audio, SrsFormat *format);
// write audio to cache, if need to flush, flush to muxer.
virtual srs_error_t write_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format);
virtual srs_error_t write_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
// write video to muxer.
virtual srs_error_t write_video(SrsSharedPtrMessage *shared_video, SrsFormat *format);
virtual srs_error_t write_video(SrsMediaPacket *shared_video, SrsFormat *format);
private:
// Reopen the muxer for a new hls segment,
@ -572,11 +572,11 @@ public:
// When publish or unpublish stream.
virtual srs_error_t on_publish(ISrsRequest *req);
virtual srs_error_t on_unpublish();
virtual srs_error_t write_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format);
virtual srs_error_t write_video(SrsSharedPtrMessage *shared_video, SrsFormat *format);
virtual srs_error_t write_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
virtual srs_error_t write_video(SrsMediaPacket *shared_video, SrsFormat *format);
public:
virtual srs_error_t on_sequence_header(SrsSharedPtrMessage *shared_audio, SrsFormat *format);
virtual srs_error_t on_sequence_header(SrsMediaPacket *shared_audio, SrsFormat *format);
virtual int sequence_no();
virtual std::string ts_url();
virtual srs_utime_t duration();
@ -637,12 +637,12 @@ public:
virtual void on_unpublish();
// Mux the audio packets to ts.
// @param shared_audio, directly ptr, copy it if need to save it.
virtual srs_error_t on_audio(SrsSharedPtrMessage *shared_audio, SrsFormat *format);
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
// Mux the video packets to ts.
// @param shared_video, directly ptr, copy it if need to save it.
// @param is_sps_pps whether the video is h.264 sps/pps.
// TODO: FIXME: Remove param is_sps_pps.
virtual srs_error_t on_video(SrsSharedPtrMessage *shared_video, SrsFormat *format);
virtual srs_error_t on_video(SrsMediaPacket *shared_video, SrsFormat *format);
private:
virtual void hls_show_mux_log();

2
trunk/src/app/srs_app_http_conn.hpp
View File

@ -29,7 +29,7 @@ class SrsHttpParser;
class ISrsHttpMessage;
class SrsHttpHandler;
class SrsMessageQueue;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsFastStream;
class SrsHttpUri;
class SrsHttpMessage;

12
trunk/src/app/srs_app_http_stream.cpp
View File

@ -188,7 +188,7 @@ srs_error_t SrsBufferCache::cycle()
// free the messages.
for (int i = 0; i < count; i++) {
SrsSharedPtrMessage *msg = msgs.msgs[i];
SrsMediaPacket *msg = msgs.msgs[i];
queue->enqueue(msg);
}
}
@ -369,7 +369,7 @@ srs_error_t SrsFlvStreamEncoder::dump_cache(SrsLiveConsumer * /*consumer*/, SrsR
return srs_success;
}
srs_error_t SrsFlvStreamEncoder::write_tags(SrsSharedPtrMessage **msgs, int count)
srs_error_t SrsFlvStreamEncoder::write_tags(SrsMediaPacket **msgs, int count)
{
srs_error_t err = srs_success;
@ -390,7 +390,7 @@ srs_error_t SrsFlvStreamEncoder::write_tags(SrsSharedPtrMessage **msgs, int coun
// Note that we must iterate all messages to count the audio and video frames.
for (int i = 0; i < count; i++) {
SrsSharedPtrMessage *msg = msgs[i];
SrsMediaPacket *msg = msgs[i];
if (msg->is_video()) {
if (!SrsFlvVideo::sh(msg->payload(), msg->size()))
nn_video_frames++;
@ -862,7 +862,7 @@ srs_error_t SrsLiveStream::do_serve_http(SrsLiveSource *source, SrsLiveConsumer
// free the messages.
for (int i = 0; i < count; i++) {
SrsSharedPtrMessage *msg = msgs.msgs[i];
SrsMediaPacket *msg = msgs.msgs[i];
srs_freep(msg);
}
@ -948,14 +948,14 @@ void SrsLiveStream::http_hooks_on_stop(ISrsHttpMessage *r)
return;
}
srs_error_t SrsLiveStream::streaming_send_messages(ISrsBufferEncoder *enc, SrsSharedPtrMessage **msgs, int nb_msgs)
srs_error_t SrsLiveStream::streaming_send_messages(ISrsBufferEncoder *enc, SrsMediaPacket **msgs, int nb_msgs)
{
srs_error_t err = srs_success;
// TODO: In gop cache, we know both the audio and video codec, so we should notice the encoder, which might depends
// on setting the correct codec information, for example, HTTP-TS or HLS will write PMT.
for (int i = 0; i < nb_msgs; i++) {
SrsSharedPtrMessage *msg = msgs[i];
SrsMediaPacket *msg = msgs[i];
if (msg->is_audio()) {
err = enc->write_audio(msg->timestamp, msg->payload(), msg->size());

4
trunk/src/app/srs_app_http_stream.hpp
View File

@ -105,7 +105,7 @@ public:
public:
// Write the tags in a time.
virtual srs_error_t write_tags(SrsSharedPtrMessage **msgs, int count);
virtual srs_error_t write_tags(SrsMediaPacket **msgs, int count);
private:
virtual srs_error_t write_header(bool has_video, bool has_audio);
@ -239,7 +239,7 @@ private:
virtual srs_error_t do_serve_http(SrsLiveSource *source, SrsLiveConsumer *consumer, ISrsHttpResponseWriter *w, ISrsHttpMessage *r);
virtual srs_error_t http_hooks_on_play(ISrsHttpMessage *r);
virtual void http_hooks_on_stop(ISrsHttpMessage *r);
virtual srs_error_t streaming_send_messages(ISrsBufferEncoder *enc, SrsSharedPtrMessage **msgs, int nb_msgs);
virtual srs_error_t streaming_send_messages(ISrsBufferEncoder *enc, SrsMediaPacket **msgs, int nb_msgs);
};
// The Live Entry, to handle HTTP Live Streaming.

23
trunk/src/app/srs_app_mpegts_udp.cpp
View File

@ -84,15 +84,15 @@ SrsMpegtsQueue::SrsMpegtsQueue()
SrsMpegtsQueue::~SrsMpegtsQueue()
{
std::map<int64_t, SrsSharedPtrMessage *>::iterator it;
std::map<int64_t, SrsMediaPacket *>::iterator it;
for (it = msgs.begin(); it != msgs.end(); ++it) {
SrsSharedPtrMessage *msg = it->second;
SrsMediaPacket *msg = it->second;
srs_freep(msg);
}
msgs.clear();
}
srs_error_t SrsMpegtsQueue::push(SrsSharedPtrMessage *msg)
srs_error_t SrsMpegtsQueue::push(SrsMediaPacket *msg)
{
srs_error_t err = srs_success;
@ -125,7 +125,7 @@ srs_error_t SrsMpegtsQueue::push(SrsSharedPtrMessage *msg)
return err;
}
SrsSharedPtrMessage *SrsMpegtsQueue::dequeue()
SrsMediaPacket *SrsMpegtsQueue::dequeue()
{
// got 2+ videos and audios, ok to dequeue.
bool av_ok = nb_videos >= 2 && nb_audios >= 2;
@ -133,8 +133,8 @@ SrsSharedPtrMessage *SrsMpegtsQueue::dequeue()
bool av_overflow = nb_videos > 100 || nb_audios > 300;
if (av_ok || av_overflow) {
std::map<int64_t, SrsSharedPtrMessage *>::iterator it = msgs.begin();
SrsSharedPtrMessage *msg = it->second;
std::map<int64_t, SrsMediaPacket *>::iterator it = msgs.begin();
SrsMediaPacket *msg = it->second;
msgs.erase(it);
if (msg->is_audio()) {
@ -604,12 +604,15 @@ srs_error_t SrsMpegtsOverUdp::rtmp_write_packet(char type, uint32_t timestamp, c
return srs_error_wrap(err, "connect");
}
SrsSharedPtrMessage *msg = NULL;
if ((err = srs_rtmp_create_msg(type, timestamp, data, size, sdk->sid(), &msg)) != srs_success) {
SrsCommonMessage *cmsg = NULL;
if ((err = srs_rtmp_create_msg(type, timestamp, data, size, sdk->sid(), &cmsg)) != srs_success) {
return srs_error_wrap(err, "create message");
}
srs_assert(msg);
srs_assert(cmsg);
SrsMediaPacket *msg = new SrsMediaPacket();
cmsg->to_msg(msg);
srs_freep(cmsg);
// push msg to queue.
if ((err = queue->push(msg)) != srs_success) {

8
trunk/src/app/srs_app_mpegts_udp.hpp
View File

@ -21,7 +21,7 @@ class SrsRtmpClient;
class SrsStSocket;
class ISrsRequest;
class SrsRawH264Stream;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsRawAacStream;
struct SrsRawAacStreamCodec;
class SrsPithyPrint;
@ -56,7 +56,7 @@ class SrsMpegtsQueue
{
private:
// The key: dts, value: msg.
std::map<int64_t, SrsSharedPtrMessage *> msgs;
std::map<int64_t, SrsMediaPacket *> msgs;
int nb_audios;
int nb_videos;
@ -65,8 +65,8 @@ public:
virtual ~SrsMpegtsQueue();
public:
virtual srs_error_t push(SrsSharedPtrMessage *msg);
virtual SrsSharedPtrMessage *dequeue();
virtual srs_error_t push(SrsMediaPacket *msg);
virtual SrsMediaPacket *dequeue();
};
// The mpegts over udp stream caster.

14
trunk/src/app/srs_app_rtc_codec.cpp
View File

@ -159,7 +159,7 @@ srs_error_t SrsAudioTranscoder::initialize(SrsAudioCodecId src_codec, SrsAudioCo
return err;
}
srs_error_t SrsAudioTranscoder::transcode(SrsAudioFrame *in_pkt, std::vector<SrsAudioFrame *> &out_pkts)
srs_error_t SrsAudioTranscoder::transcode(SrsParsedAudioPacket *in_pkt, std::vector<SrsParsedAudioPacket *> &out_pkts)
{
srs_error_t err = srs_success;
@ -174,10 +174,10 @@ srs_error_t SrsAudioTranscoder::transcode(SrsAudioFrame *in_pkt, std::vector<Srs
return err;
}
void SrsAudioTranscoder::free_frames(std::vector<SrsAudioFrame *> &frames)
void SrsAudioTranscoder::free_frames(std::vector<SrsParsedAudioPacket *> &frames)
{
for (std::vector<SrsAudioFrame *>::iterator it = frames.begin(); it != frames.end(); ++it) {
SrsAudioFrame *p = *it;
for (std::vector<SrsParsedAudioPacket *>::iterator it = frames.begin(); it != frames.end(); ++it) {
SrsParsedAudioPacket *p = *it;
for (int i = 0; i < p->nb_samples; i++) {
char *pa = p->samples[i].bytes;
@ -325,7 +325,7 @@ srs_error_t SrsAudioTranscoder::init_fifo()
return srs_success;
}
srs_error_t SrsAudioTranscoder::decode_and_resample(SrsAudioFrame *pkt)
srs_error_t SrsAudioTranscoder::decode_and_resample(SrsParsedAudioPacket *pkt)
{
srs_error_t err = srs_success;
@ -380,7 +380,7 @@ srs_error_t SrsAudioTranscoder::decode_and_resample(SrsAudioFrame *pkt)
return err;
}
srs_error_t SrsAudioTranscoder::encode(std::vector<SrsAudioFrame *> &pkts)
srs_error_t SrsAudioTranscoder::encode(std::vector<SrsParsedAudioPacket *> &pkts)
{
char err_buf[AV_ERROR_MAX_STRING_SIZE] = {0};
@ -435,7 +435,7 @@ srs_error_t SrsAudioTranscoder::encode(std::vector<SrsAudioFrame *> &pkts)
enc_packet_->dts = av_rescale(enc_packet_->dts, 1000, enc_->time_base.den);
enc_packet_->pts = av_rescale(enc_packet_->pts, 1000, enc_->time_base.den);
SrsAudioFrame *out_frame = new SrsAudioFrame;
SrsParsedAudioPacket *out_frame = new SrsParsedAudioPacket;
char *buf = new char[enc_packet_->size];
memcpy(buf, enc_packet_->data, enc_packet_->size);
out_frame->add_sample(buf, enc_packet_->size);

9
trunk/src/app/srs_app_rtc_codec.hpp
View File

@ -10,6 +10,7 @@
#include <srs_core.hpp>
#include <srs_kernel_codec.hpp>
#include <srs_kernel_packet.hpp>
#include <string>
@ -60,9 +61,9 @@ public:
// The bit_rate specifies the bitrate of encoder, for example, 48000.
srs_error_t initialize(SrsAudioCodecId from, SrsAudioCodecId to, int channels, int sample_rate, int bit_rate);
// Transcode the input audio frame in, as output audio frames outs.
virtual srs_error_t transcode(SrsAudioFrame *in, std::vector<SrsAudioFrame *> &outs);
virtual srs_error_t transcode(SrsParsedAudioPacket *in, std::vector<SrsParsedAudioPacket *> &outs);
// Free the generated audio frames by transcode.
void free_frames(std::vector<SrsAudioFrame *> &frames);
void free_frames(std::vector<SrsParsedAudioPacket *> &frames);
public:
// Get the aac codec header, for example, FLV sequence header.
@ -75,8 +76,8 @@ private:
srs_error_t init_swr(AVCodecContext *decoder);
srs_error_t init_fifo();
srs_error_t decode_and_resample(SrsAudioFrame *pkt);
srs_error_t encode(std::vector<SrsAudioFrame *> &pkts);
srs_error_t decode_and_resample(SrsParsedAudioPacket *pkt);
srs_error_t encode(std::vector<SrsParsedAudioPacket *> &pkts);
srs_error_t add_samples_to_fifo(uint8_t **samples, int frame_size);
void free_swr_samples();

2
trunk/src/app/srs_app_rtc_conn.hpp
View File

@ -35,7 +35,7 @@ class SrsLiveConsumer;
class SrsStunPacket;
class SrsServer;
class SrsRtcConnection;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsRtcSource;
class SrsRtpPacket;
class ISrsCodec;

100
trunk/src/app/srs_app_rtc_source.cpp
View File

@ -68,7 +68,7 @@ using namespace std;
#define SRS_RTC_SOURCE_CLEANUP (3 * SRS_UTIME_SECONDS)
// TODO: Add this function into SrsRtpMux class.
srs_error_t aac_raw_append_adts_header(SrsSharedPtrMessage *shared_audio, SrsFormat *format, char **pbuf, int *pnn_buf)
srs_error_t aac_raw_append_adts_header(SrsMediaPacket *shared_audio, SrsFormat *format, char **pbuf, int *pnn_buf)
{
srs_error_t err = srs_success;
@ -1005,7 +1005,7 @@ void SrsRtcRtpBuilder::on_unpublish()
meta->update_previous_ash();
}
srs_error_t SrsRtcRtpBuilder::on_frame(SrsSharedPtrMessage *frame)
srs_error_t SrsRtcRtpBuilder::on_frame(SrsMediaPacket *frame)
{
if (frame->is_audio()) {
return on_audio(frame);
@ -1015,7 +1015,7 @@ srs_error_t SrsRtcRtpBuilder::on_frame(SrsSharedPtrMessage *frame)
return srs_success;
}
srs_error_t SrsRtcRtpBuilder::on_audio(SrsSharedPtrMessage *msg)
srs_error_t SrsRtcRtpBuilder::on_audio(SrsMediaPacket *msg)
{
srs_error_t err = srs_success;
@ -1072,7 +1072,7 @@ srs_error_t SrsRtcRtpBuilder::on_audio(SrsSharedPtrMessage *msg)
return err;
}
SrsAudioFrame aac;
SrsParsedAudioPacket aac;
aac.dts = format->audio->dts;
aac.cts = format->audio->cts;
if ((err = aac.add_sample(adts_audio, nn_adts_audio)) == srs_success) {
@ -1115,11 +1115,11 @@ srs_error_t SrsRtcRtpBuilder::init_codec(SrsAudioCodecId codec)
return err;
}
srs_error_t SrsRtcRtpBuilder::transcode(SrsAudioFrame *audio)
srs_error_t SrsRtcRtpBuilder::transcode(SrsParsedAudioPacket *audio)
{
srs_error_t err = srs_success;
std::vector<SrsAudioFrame *> out_audios;
std::vector<SrsParsedAudioPacket *> out_audios;
if ((err = codec_->transcode(audio, out_audios)) != srs_success) {
return srs_error_wrap(err, "recode error");
}
@ -1129,8 +1129,8 @@ srs_error_t SrsRtcRtpBuilder::transcode(SrsAudioFrame *audio)
return err;
}
for (std::vector<SrsAudioFrame *>::iterator it = out_audios.begin(); it != out_audios.end(); ++it) {
SrsAudioFrame *out_audio = *it;
for (std::vector<SrsParsedAudioPacket *>::iterator it = out_audios.begin(); it != out_audios.end(); ++it) {
SrsParsedAudioPacket *out_audio = *it;
SrsUniquePtr<SrsRtpPacket> pkt(new SrsRtpPacket());
if ((err = package_opus(out_audio, pkt.get())) != srs_success) {
@ -1149,7 +1149,7 @@ srs_error_t SrsRtcRtpBuilder::transcode(SrsAudioFrame *audio)
return err;
}
srs_error_t SrsRtcRtpBuilder::package_opus(SrsAudioFrame *audio, SrsRtpPacket *pkt)
srs_error_t SrsRtcRtpBuilder::package_opus(SrsParsedAudioPacket *audio, SrsRtpPacket *pkt)
{
srs_error_t err = srs_success;
@ -1181,7 +1181,7 @@ static void free_packets(vector<SrsRtpPacket *> *pkts)
pkts->clear();
}
srs_error_t SrsRtcRtpBuilder::on_video(SrsSharedPtrMessage *msg)
srs_error_t SrsRtcRtpBuilder::on_video(SrsMediaPacket *msg)
{
srs_error_t err = srs_success;
@ -1216,7 +1216,7 @@ srs_error_t SrsRtcRtpBuilder::on_video(SrsSharedPtrMessage *msg)
}
bool has_idr = false;
vector<SrsSample *> samples;
vector<SrsNaluSample *> samples;
if ((err = filter(msg, format, has_idr, samples)) != srs_success) {
return srs_error_wrap(err, "filter video");
}
@ -1247,7 +1247,7 @@ srs_error_t SrsRtcRtpBuilder::on_video(SrsSharedPtrMessage *msg)
} else {
// By default, we package each NALU(sample) to a RTP or FUA packet.
for (int i = 0; i < nn_samples; i++) {
SrsSample *sample = samples[i];
SrsNaluSample *sample = samples[i];
if (sample->size <= kRtpMaxPayloadSize) {
if ((err = package_single_nalu(msg, sample, pkts)) != srs_success) {
@ -1268,7 +1268,7 @@ srs_error_t SrsRtcRtpBuilder::on_video(SrsSharedPtrMessage *msg)
return consume_packets(pkts);
}
srs_error_t SrsRtcRtpBuilder::filter(SrsSharedPtrMessage *msg, SrsFormat *format, bool &has_idr, vector<SrsSample *> &samples)
srs_error_t SrsRtcRtpBuilder::filter(SrsMediaPacket *msg, SrsFormat *format, bool &has_idr, vector<SrsNaluSample *> &samples)
{
srs_error_t err = srs_success;
@ -1279,12 +1279,12 @@ srs_error_t SrsRtcRtpBuilder::filter(SrsSharedPtrMessage *msg, SrsFormat *format
// Update samples to shared frame.
for (int i = 0; i < format->video->nb_samples; ++i) {
SrsSample *sample = &format->video->samples[i];
SrsNaluSample *sample = &format->video->samples[i];
if (!keep_avc_nalu_sei && format->vcodec->id == SrsVideoCodecIdAVC) {
SrsAvcNaluType avc_nalu_type;
if ((err = SrsVideoFrame::parse_avc_nalu_type(sample, avc_nalu_type)) != srs_success) {
if ((err = SrsParsedVideoPacket::parse_avc_nalu_type(sample, avc_nalu_type)) != srs_success) {
return srs_error_wrap(err, "parse avc nalu_type");
}
if (avc_nalu_type == SrsAvcNaluTypeSEI) {
@ -1298,11 +1298,11 @@ srs_error_t SrsRtcRtpBuilder::filter(SrsSharedPtrMessage *msg, SrsFormat *format
if (!keep_bframe) {
bool is_b_frame = false;
if (format->vcodec->id == SrsVideoCodecIdAVC) {
if ((err = SrsVideoFrame::parse_avc_bframe(sample, is_b_frame)) != srs_success) {
if ((err = SrsParsedVideoPacket::parse_avc_bframe(sample, is_b_frame)) != srs_success) {
return srs_error_wrap(err, "parse bframe");
}
} else if (format->vcodec->id == SrsVideoCodecIdHEVC) {
if ((err = SrsVideoFrame::parse_hevc_bframe(sample, format, is_b_frame)) != srs_success) {
if ((err = SrsParsedVideoPacket::parse_hevc_bframe(sample, format, is_b_frame)) != srs_success) {
return srs_error_wrap(err, "parse bframe");
}
}
@ -1317,7 +1317,7 @@ srs_error_t SrsRtcRtpBuilder::filter(SrsSharedPtrMessage *msg, SrsFormat *format
return err;
}
srs_error_t SrsRtcRtpBuilder::package_stap_a(SrsSharedPtrMessage *msg, SrsRtpPacket *pkt)
srs_error_t SrsRtcRtpBuilder::package_stap_a(SrsMediaPacket *msg, SrsRtpPacket *pkt)
{
srs_error_t err = srs_success;
@ -1329,7 +1329,7 @@ srs_error_t SrsRtcRtpBuilder::package_stap_a(SrsSharedPtrMessage *msg, SrsRtpPac
return video_builder_->package_stap_a(msg, pkt);
}
srs_error_t SrsRtcRtpBuilder::package_nalus(SrsSharedPtrMessage *msg, const vector<SrsSample *> &samples, vector<SrsRtpPacket *> &pkts)
srs_error_t SrsRtcRtpBuilder::package_nalus(SrsMediaPacket *msg, const vector<SrsNaluSample *> &samples, vector<SrsRtpPacket *> &pkts)
{
srs_error_t err = srs_success;
@ -1342,12 +1342,12 @@ srs_error_t SrsRtcRtpBuilder::package_nalus(SrsSharedPtrMessage *msg, const vect
}
// Single NAL Unit Packet @see https://tools.ietf.org/html/rfc6184#section-5.6
srs_error_t SrsRtcRtpBuilder::package_single_nalu(SrsSharedPtrMessage *msg, SrsSample *sample, vector<SrsRtpPacket *> &pkts)
srs_error_t SrsRtcRtpBuilder::package_single_nalu(SrsMediaPacket *msg, SrsNaluSample *sample, vector<SrsRtpPacket *> &pkts)
{
return video_builder_->package_single_nalu(msg, sample, pkts);
}
srs_error_t SrsRtcRtpBuilder::package_fu_a(SrsSharedPtrMessage *msg, SrsSample *sample, int fu_payload_size, vector<SrsRtpPacket *> &pkts)
srs_error_t SrsRtcRtpBuilder::package_fu_a(SrsMediaPacket *msg, SrsNaluSample *sample, int fu_payload_size, vector<SrsRtpPacket *> &pkts)
{
srs_error_t err = srs_success;
@ -1867,10 +1867,8 @@ srs_error_t SrsRtcFrameBuilder::transcode_audio(SrsRtpPacket *pkt)
SrsCommonMessage out_rtmp;
packet_aac(&out_rtmp, (char *)header, header_len, ts, is_first_audio_);
SrsSharedPtrMessage msg;
if ((err = msg.create(&out_rtmp)) != srs_success) {
return srs_error_wrap(err, "create message");
}
SrsMediaPacket msg;
out_rtmp.to_msg(&msg);
if ((err = bridge_->on_frame(&msg)) != srs_success) {
return srs_error_wrap(err, "source on audio");
@ -1880,10 +1878,10 @@ srs_error_t SrsRtcFrameBuilder::transcode_audio(SrsRtpPacket *pkt)
}
// TODO: FIXME: Should use SrsUniquePtr to dispose it automatically.
std::vector<SrsAudioFrame *> out_pkts;
std::vector<SrsParsedAudioPacket *> out_pkts;
SrsRtpRawPayload *payload = dynamic_cast<SrsRtpRawPayload *>(pkt->payload());
SrsAudioFrame frame;
SrsParsedAudioPacket frame;
frame.add_sample(payload->payload, payload->nn_payload);
frame.dts = ts;
frame.cts = 0;
@ -1893,16 +1891,14 @@ srs_error_t SrsRtcFrameBuilder::transcode_audio(SrsRtpPacket *pkt)
return err;
}
for (std::vector<SrsAudioFrame *>::iterator it = out_pkts.begin(); it != out_pkts.end(); ++it) {
for (std::vector<SrsParsedAudioPacket *>::iterator it = out_pkts.begin(); it != out_pkts.end(); ++it) {
SrsCommonMessage out_rtmp;
// TODO: FIXME: Should never directly use it, please define a variable with class name.
out_rtmp.header.timestamp = (*it)->dts;
packet_aac(&out_rtmp, (*it)->samples[0].bytes, (*it)->samples[0].size, ts, is_first_audio_);
SrsSharedPtrMessage msg;
if ((err = msg.create(&out_rtmp)) != srs_success) {
return srs_error_wrap(err, "create message");
}
SrsMediaPacket msg;
out_rtmp.to_msg(&msg);
if ((err = bridge_->on_frame(&msg)) != srs_success) {
err = srs_error_wrap(err, "source on audio");
@ -2023,10 +2019,10 @@ srs_error_t SrsRtcFrameBuilder::packet_sequence_header_avc(SrsRtpPacket *pkt)
// Handle SPS/PPS in cache or STAP-A packet.
if (stap_payload || has_sps_pps_in_raw_payload) {
// Get the SPS/PPS from cache or STAP-A packet.
SrsSample *sps = stap_payload ? stap_payload->get_sps() : NULL;
SrsNaluSample *sps = stap_payload ? stap_payload->get_sps() : NULL;
if (!sps && obs_whip_sps_)
sps = dynamic_cast<SrsRtpRawPayload *>(obs_whip_sps_->payload())->sample_;
SrsSample *pps = stap_payload ? stap_payload->get_pps() : NULL;
SrsNaluSample *pps = stap_payload ? stap_payload->get_pps() : NULL;
if (!pps && obs_whip_pps_)
pps = dynamic_cast<SrsRtpRawPayload *>(obs_whip_pps_->payload())->sample_;
if (!sps || !pps) {
@ -2048,7 +2044,7 @@ srs_error_t SrsRtcFrameBuilder::packet_sequence_header_avc(SrsRtpPacket *pkt)
return err;
}
srs_error_t SrsRtcFrameBuilder::do_packet_sequence_header_avc(SrsRtpPacket *pkt, SrsSample *sps, SrsSample *pps)
srs_error_t SrsRtcFrameBuilder::do_packet_sequence_header_avc(SrsRtpPacket *pkt, SrsNaluSample *sps, SrsNaluSample *pps)
{
srs_error_t err = srs_success;
@ -2078,10 +2074,8 @@ srs_error_t SrsRtcFrameBuilder::do_packet_sequence_header_avc(SrsRtpPacket *pkt,
return srs_error_wrap(err, "create rtmp");
}
SrsSharedPtrMessage msg;
if ((err = msg.create(&rtmp)) != srs_success) {
return srs_error_wrap(err, "create message");
}
SrsMediaPacket msg;
rtmp.to_msg(&msg);
if ((err = bridge_->on_frame(&msg)) != srs_success) {
return err;
@ -2121,13 +2115,13 @@ srs_error_t SrsRtcFrameBuilder::packet_sequence_header_hevc(SrsRtpPacket *pkt)
// Generally, there will be SPS+PPS+IDR in a STAP-A packet.
SrsRtpSTAPPayloadHevc *stap_payload_hevc = dynamic_cast<SrsRtpSTAPPayloadHevc *>(pkt->payload());
if (video_codec_ == SrsVideoCodecIdHEVC && (stap_payload_hevc || has_vps_sps_pps_in_raw_payload)) {
SrsSample *vps = stap_payload_hevc ? stap_payload_hevc->get_vps() : NULL;
SrsNaluSample *vps = stap_payload_hevc ? stap_payload_hevc->get_vps() : NULL;
if (!vps && obs_whip_vps_)
vps = dynamic_cast<SrsRtpRawPayload *>(obs_whip_vps_->payload())->sample_;
SrsSample *sps = stap_payload_hevc ? stap_payload_hevc->get_sps() : NULL;
SrsNaluSample *sps = stap_payload_hevc ? stap_payload_hevc->get_sps() : NULL;
if (!sps && obs_whip_sps_)
sps = dynamic_cast<SrsRtpRawPayload *>(obs_whip_sps_->payload())->sample_;
SrsSample *pps = stap_payload_hevc ? stap_payload_hevc->get_pps() : NULL;
SrsNaluSample *pps = stap_payload_hevc ? stap_payload_hevc->get_pps() : NULL;
if (!pps && obs_whip_pps_)
pps = dynamic_cast<SrsRtpRawPayload *>(obs_whip_pps_->payload())->sample_;
if (!vps || !sps || !pps) {
@ -2149,7 +2143,7 @@ srs_error_t SrsRtcFrameBuilder::packet_sequence_header_hevc(SrsRtpPacket *pkt)
return err;
}
srs_error_t SrsRtcFrameBuilder::do_packet_sequence_header_hevc(SrsRtpPacket *pkt, SrsSample *vps, SrsSample *sps, SrsSample *pps)
srs_error_t SrsRtcFrameBuilder::do_packet_sequence_header_hevc(SrsRtpPacket *pkt, SrsNaluSample *vps, SrsNaluSample *sps, SrsNaluSample *pps)
{
srs_error_t err = srs_success;
@ -2177,10 +2171,8 @@ srs_error_t SrsRtcFrameBuilder::do_packet_sequence_header_hevc(SrsRtpPacket *pkt
return srs_error_wrap(err, "create rtmp");
}
SrsSharedPtrMessage msg;
if ((err = msg.create(&rtmp)) != srs_success) {
return srs_error_wrap(err, "create message");
}
SrsMediaPacket msg;
rtmp.to_msg(&msg);
if ((err = bridge_->on_frame(&msg)) != srs_success) {
return err;
@ -2210,7 +2202,7 @@ int SrsRtcFrameBuilder::calculate_packet_payload_size(SrsRtpPacket *pkt)
if (stap_payload) {
int size = 0;
for (int j = 0; j < (int)stap_payload->nalus.size(); ++j) {
SrsSample *sample = stap_payload->nalus.at(j);
SrsNaluSample *sample = stap_payload->nalus.at(j);
if (sample->size > 0) {
size += 4 + sample->size; // length prefix + NALU
}
@ -2233,7 +2225,7 @@ int SrsRtcFrameBuilder::calculate_packet_payload_size(SrsRtpPacket *pkt)
if (stap_payload_hevc) {
int size = 0;
for (int j = 0; j < (int)stap_payload_hevc->nalus.size(); ++j) {
SrsSample *sample = stap_payload_hevc->nalus.at(j);
SrsNaluSample *sample = stap_payload_hevc->nalus.at(j);
if (sample->size > 0) {
size += 4 + sample->size; // length prefix + NALU
}
@ -2281,7 +2273,7 @@ void SrsRtcFrameBuilder::write_packet_payload_to_buffer(SrsRtpPacket *pkt, SrsBu
SrsRtpSTAPPayload *stap_payload = dynamic_cast<SrsRtpSTAPPayload *>(pkt->payload());
if (stap_payload) {
for (int j = 0; j < (int)stap_payload->nalus.size(); ++j) {
SrsSample *sample = stap_payload->nalus.at(j);
SrsNaluSample *sample = stap_payload->nalus.at(j);
if (sample->size > 0) {
payload.write_4bytes(sample->size);
payload.write_bytes(sample->bytes, sample->size);
@ -2316,7 +2308,7 @@ void SrsRtcFrameBuilder::write_packet_payload_to_buffer(SrsRtpPacket *pkt, SrsBu
SrsRtpSTAPPayloadHevc *stap_payload_hevc = dynamic_cast<SrsRtpSTAPPayloadHevc *>(pkt->payload());
if (stap_payload_hevc) {
for (int j = 0; j < (int)stap_payload_hevc->nalus.size(); ++j) {
SrsSample *sample = stap_payload_hevc->nalus.at(j);
SrsNaluSample *sample = stap_payload_hevc->nalus.at(j);
if (sample->size > 0) {
payload.write_4bytes(sample->size);
payload.write_bytes(sample->bytes, sample->size);
@ -2435,10 +2427,8 @@ srs_error_t SrsRtcFrameBuilder::packet_video_rtmp(const uint16_t start, const ui
write_packet_payload_to_buffer(pkt.get(), payload, nalu_len);
}
SrsSharedPtrMessage msg;
if ((err = msg.create(&rtmp)) != srs_success) {
return srs_error_wrap(err, "create message");
}
SrsMediaPacket msg;
rtmp.to_msg(&msg);
if ((err = bridge_->on_frame(&msg)) != srs_success) {
srs_warn("fail to pack video frame: %s", srs_error_summary(err).c_str());

28
trunk/src/app/srs_app_rtc_source.hpp
View File

@ -24,14 +24,14 @@
class ISrsRequest;
class SrsMetaCache;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsCommonMessage;
class SrsMessageArray;
class SrsRtcSource;
class SrsFrameToRtcBridge;
class SrsAudioTranscoder;
class SrsRtpPacket;
class SrsSample;
class SrsNaluSample;
class SrsRtcSourceDescription;
class SrsRtcTrackDescription;
class SrsRtcConnection;
@ -346,25 +346,25 @@ public:
virtual srs_error_t initialize(ISrsRequest *r);
virtual srs_error_t on_publish();
virtual void on_unpublish();
virtual srs_error_t on_frame(SrsSharedPtrMessage *frame);
virtual srs_error_t on_frame(SrsMediaPacket *frame);
private:
virtual srs_error_t on_audio(SrsSharedPtrMessage *msg);
virtual srs_error_t on_audio(SrsMediaPacket *msg);
private:
srs_error_t init_codec(SrsAudioCodecId codec);
srs_error_t transcode(SrsAudioFrame *audio);
srs_error_t package_opus(SrsAudioFrame *audio, SrsRtpPacket *pkt);
srs_error_t transcode(SrsParsedAudioPacket *audio);
srs_error_t package_opus(SrsParsedAudioPacket *audio, SrsRtpPacket *pkt);
private:
virtual srs_error_t on_video(SrsSharedPtrMessage *msg);
virtual srs_error_t on_video(SrsMediaPacket *msg);
private:
srs_error_t filter(SrsSharedPtrMessage *msg, SrsFormat *format, bool &has_idr, std::vector<SrsSample *> &samples);
srs_error_t package_stap_a(SrsSharedPtrMessage *msg, SrsRtpPacket *pkt);
srs_error_t package_nalus(SrsSharedPtrMessage *msg, const std::vector<SrsSample *> &samples, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_single_nalu(SrsSharedPtrMessage *msg, SrsSample *sample, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_fu_a(SrsSharedPtrMessage *msg, SrsSample *sample, int fu_payload_size, std::vector<SrsRtpPacket *> &pkts);
srs_error_t filter(SrsMediaPacket *msg, SrsFormat *format, bool &has_idr, std::vector<SrsNaluSample *> &samples);
srs_error_t package_stap_a(SrsMediaPacket *msg, SrsRtpPacket *pkt);
srs_error_t package_nalus(SrsMediaPacket *msg, const std::vector<SrsNaluSample *> &samples, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_single_nalu(SrsMediaPacket *msg, SrsNaluSample *sample, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_fu_a(SrsMediaPacket *msg, SrsNaluSample *sample, int fu_payload_size, std::vector<SrsRtpPacket *> &pkts);
srs_error_t consume_packets(std::vector<SrsRtpPacket *> &pkts);
};
@ -504,9 +504,9 @@ private:
srs_error_t packet_video(SrsRtpPacket *pkt);
srs_error_t packet_video_key_frame(SrsRtpPacket *pkt);
srs_error_t packet_sequence_header_avc(SrsRtpPacket *pkt);
srs_error_t do_packet_sequence_header_avc(SrsRtpPacket *pkt, SrsSample *sps, SrsSample *pps);
srs_error_t do_packet_sequence_header_avc(SrsRtpPacket *pkt, SrsNaluSample *sps, SrsNaluSample *pps);
srs_error_t packet_sequence_header_hevc(SrsRtpPacket *pkt);
srs_error_t do_packet_sequence_header_hevc(SrsRtpPacket *pkt, SrsSample *vps, SrsSample *sps, SrsSample *pps);
srs_error_t do_packet_sequence_header_hevc(SrsRtpPacket *pkt, SrsNaluSample *vps, SrsNaluSample *sps, SrsNaluSample *pps);
private:
srs_error_t packet_video_rtmp(const uint16_t start, const uint16_t end);

14
trunk/src/app/srs_app_rtmp_conn.cpp
View File

@ -825,7 +825,7 @@ srs_error_t SrsRtmpConn::do_playing(SrsSharedPtr<SrsLiveSource> source, SrsLiveC
// we start to collect the durations for each message.
if (user_specified_duration_to_stop) {
for (int i = 0; i < count; i++) {
SrsSharedPtrMessage *msg = msgs.msgs[i];
SrsMediaPacket *msg = msgs.msgs[i];
// foreach msg, collect the duration.
// @remark: never use msg when sent it, for the protocol sdk will free it.
@ -1109,11 +1109,11 @@ srs_error_t SrsRtmpConn::handle_publish_message(SrsSharedPtr<SrsLiveSource> &sou
// process publish event.
if (msg->header.is_amf0_command() || msg->header.is_amf3_command()) {
SrsPacket *pkt_raw = NULL;
SrsRtmpCommand *pkt_raw = NULL;
if ((err = rtmp->decode_message(msg, &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "rtmp: decode message");
}
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
SrsUniquePtr<SrsRtmpCommand> pkt(pkt_raw);
// for flash, any packet is republish.
if (info->type == SrsRtmpConnFlashPublish) {
@ -1181,11 +1181,11 @@ srs_error_t SrsRtmpConn::process_publish_message(SrsSharedPtr<SrsLiveSource> &so
// process onMetaData
if (msg->header.is_amf0_data() || msg->header.is_amf3_data()) {
SrsPacket *pkt_raw = NULL;
SrsRtmpCommand *pkt_raw = NULL;
if ((err = rtmp->decode_message(msg, &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "rtmp: decode message");
}
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
SrsUniquePtr<SrsRtmpCommand> pkt(pkt_raw);
if (dynamic_cast<SrsOnMetaDataPacket *>(pkt.get())) {
SrsOnMetaDataPacket *metadata = dynamic_cast<SrsOnMetaDataPacket *>(pkt.get());
@ -1213,11 +1213,11 @@ srs_error_t SrsRtmpConn::process_play_control_msg(SrsLiveConsumer *consumer, Srs
return err;
}
SrsPacket *pkt_raw = NULL;
SrsRtmpCommand *pkt_raw = NULL;
if ((err = rtmp->decode_message(msg.get(), &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "rtmp: decode message");
}
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
SrsUniquePtr<SrsRtmpCommand> pkt(pkt_raw);
// for jwplayer/flowplayer, which send close as pause message.
SrsCloseStreamPacket *close = dynamic_cast<SrsCloseStreamPacket *>(pkt.get());

4
trunk/src/app/srs_app_rtmp_conn.hpp
View File

@ -31,13 +31,13 @@ class SrsHttpHooks;
class SrsBandwidth;
class SrsKbps;
class SrsRtmpClient;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsQueueRecvThread;
class SrsPublishRecvThread;
class SrsSecurity;
class ISrsWakable;
class SrsCommonMessage;
class SrsPacket;
class SrsRtmpCommand;
class SrsNetworkDelta;
class SrsSslConnection;

24
trunk/src/app/srs_app_rtsp_source.cpp
View File

@ -692,7 +692,7 @@ void SrsRtspRtpBuilder::on_unpublish()
meta->update_previous_ash();
}
srs_error_t SrsRtspRtpBuilder::on_frame(SrsSharedPtrMessage *frame)
srs_error_t SrsRtspRtpBuilder::on_frame(SrsMediaPacket *frame)
{
if (frame->is_audio()) {
return on_audio(frame);
@ -702,7 +702,7 @@ srs_error_t SrsRtspRtpBuilder::on_frame(SrsSharedPtrMessage *frame)
return srs_success;
}
srs_error_t SrsRtspRtpBuilder::on_audio(SrsSharedPtrMessage *msg)
srs_error_t SrsRtspRtpBuilder::on_audio(SrsMediaPacket *msg)
{
srs_error_t err = srs_success;
@ -753,7 +753,7 @@ srs_error_t SrsRtspRtpBuilder::on_audio(SrsSharedPtrMessage *msg)
return err;
}
srs_error_t SrsRtspRtpBuilder::package_aac(SrsAudioFrame *audio, SrsRtpPacket *pkt)
srs_error_t SrsRtspRtpBuilder::package_aac(SrsParsedAudioPacket *audio, SrsRtpPacket *pkt)
{
srs_error_t err = srs_success;
@ -827,7 +827,7 @@ static void free_packets(vector<SrsRtpPacket *> *pkts)
pkts->clear();
}
srs_error_t SrsRtspRtpBuilder::on_video(SrsSharedPtrMessage *msg)
srs_error_t SrsRtspRtpBuilder::on_video(SrsMediaPacket *msg)
{
srs_error_t err = srs_success;
@ -862,7 +862,7 @@ srs_error_t SrsRtspRtpBuilder::on_video(SrsSharedPtrMessage *msg)
}
bool has_idr = false;
vector<SrsSample *> samples;
vector<SrsNaluSample *> samples;
if ((err = filter(msg, format, has_idr, samples)) != srs_success) {
return srs_error_wrap(err, "filter video");
}
@ -888,7 +888,7 @@ srs_error_t SrsRtspRtpBuilder::on_video(SrsSharedPtrMessage *msg)
// By default, we package each NALU(sample) to a RTP or FUA packet.
for (int i = 0; i < nn_samples; i++) {
SrsSample *sample = samples[i];
SrsNaluSample *sample = samples[i];
if (sample->size <= kRtpMaxPayloadSize) {
if ((err = package_single_nalu(msg, sample, pkts)) != srs_success) {
@ -908,7 +908,7 @@ srs_error_t SrsRtspRtpBuilder::on_video(SrsSharedPtrMessage *msg)
return consume_packets(pkts);
}
srs_error_t SrsRtspRtpBuilder::filter(SrsSharedPtrMessage *msg, SrsFormat *format, bool &has_idr, vector<SrsSample *> &samples)
srs_error_t SrsRtspRtpBuilder::filter(SrsMediaPacket *msg, SrsFormat *format, bool &has_idr, vector<SrsNaluSample *> &samples)
{
srs_error_t err = srs_success;
@ -919,14 +919,14 @@ srs_error_t SrsRtspRtpBuilder::filter(SrsSharedPtrMessage *msg, SrsFormat *forma
// Update samples to shared frame.
for (int i = 0; i < format->video->nb_samples; ++i) {
SrsSample *sample = &format->video->samples[i];
SrsNaluSample *sample = &format->video->samples[i];
samples.push_back(sample);
}
return err;
}
srs_error_t SrsRtspRtpBuilder::package_stap_a(SrsSharedPtrMessage *msg, SrsRtpPacket *pkt)
srs_error_t SrsRtspRtpBuilder::package_stap_a(SrsMediaPacket *msg, SrsRtpPacket *pkt)
{
srs_error_t err = srs_success;
@ -938,7 +938,7 @@ srs_error_t SrsRtspRtpBuilder::package_stap_a(SrsSharedPtrMessage *msg, SrsRtpPa
return video_builder_->package_stap_a(msg, pkt);
}
srs_error_t SrsRtspRtpBuilder::package_nalus(SrsSharedPtrMessage *msg, const vector<SrsSample *> &samples, vector<SrsRtpPacket *> &pkts)
srs_error_t SrsRtspRtpBuilder::package_nalus(SrsMediaPacket *msg, const vector<SrsNaluSample *> &samples, vector<SrsRtpPacket *> &pkts)
{
srs_error_t err = srs_success;
@ -951,12 +951,12 @@ srs_error_t SrsRtspRtpBuilder::package_nalus(SrsSharedPtrMessage *msg, const vec
}
// Single NAL Unit Packet @see https://tools.ietf.org/html/rfc6184#section-5.6
srs_error_t SrsRtspRtpBuilder::package_single_nalu(SrsSharedPtrMessage *msg, SrsSample *sample, vector<SrsRtpPacket *> &pkts)
srs_error_t SrsRtspRtpBuilder::package_single_nalu(SrsMediaPacket *msg, SrsNaluSample *sample, vector<SrsRtpPacket *> &pkts)
{
return video_builder_->package_single_nalu(msg, sample, pkts);
}
srs_error_t SrsRtspRtpBuilder::package_fu_a(SrsSharedPtrMessage *msg, SrsSample *sample, int fu_payload_size, vector<SrsRtpPacket *> &pkts)
srs_error_t SrsRtspRtpBuilder::package_fu_a(SrsMediaPacket *msg, SrsNaluSample *sample, int fu_payload_size, vector<SrsRtpPacket *> &pkts)
{
srs_error_t err = srs_success;

18
trunk/src/app/srs_app_rtsp_source.hpp
View File

@ -223,23 +223,23 @@ public:
virtual srs_error_t initialize(ISrsRequest *r);
virtual srs_error_t on_publish();
virtual void on_unpublish();
virtual srs_error_t on_frame(SrsSharedPtrMessage *frame);
virtual srs_error_t on_frame(SrsMediaPacket *frame);
private:
virtual srs_error_t on_audio(SrsSharedPtrMessage *msg);
virtual srs_error_t on_audio(SrsMediaPacket *msg);
private:
srs_error_t package_aac(SrsAudioFrame *audio, SrsRtpPacket *pkt);
srs_error_t package_aac(SrsParsedAudioPacket *audio, SrsRtpPacket *pkt);
private:
virtual srs_error_t on_video(SrsSharedPtrMessage *msg);
virtual srs_error_t on_video(SrsMediaPacket *msg);
private:
srs_error_t filter(SrsSharedPtrMessage *msg, SrsFormat *format, bool &has_idr, std::vector<SrsSample *> &samples);
srs_error_t package_stap_a(SrsSharedPtrMessage *msg, SrsRtpPacket *pkt);
srs_error_t package_nalus(SrsSharedPtrMessage *msg, const std::vector<SrsSample *> &samples, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_single_nalu(SrsSharedPtrMessage *msg, SrsSample *sample, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_fu_a(SrsSharedPtrMessage *msg, SrsSample *sample, int fu_payload_size, std::vector<SrsRtpPacket *> &pkts);
srs_error_t filter(SrsMediaPacket *msg, SrsFormat *format, bool &has_idr, std::vector<SrsNaluSample *> &samples);
srs_error_t package_stap_a(SrsMediaPacket *msg, SrsRtpPacket *pkt);
srs_error_t package_nalus(SrsMediaPacket *msg, const std::vector<SrsNaluSample *> &samples, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_single_nalu(SrsMediaPacket *msg, SrsNaluSample *sample, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_fu_a(SrsMediaPacket *msg, SrsNaluSample *sample, int fu_payload_size, std::vector<SrsRtpPacket *> &pkts);
srs_error_t consume_packets(std::vector<SrsRtpPacket *> &pkts);
};

140
trunk/src/app/srs_app_source.cpp
View File

@ -70,7 +70,7 @@ SrsRtmpJitter::~SrsRtmpJitter()
{
}
srs_error_t SrsRtmpJitter::correct(SrsSharedPtrMessage *msg, SrsRtmpJitterAlgorithm ag)
srs_error_t SrsRtmpJitter::correct(SrsMediaPacket *msg, SrsRtmpJitterAlgorithm ag)
{
srs_error_t err = srs_success;
@ -140,7 +140,7 @@ SrsFastVector::SrsFastVector()
{
count = 0;
nb_msgs = 8;
msgs = new SrsSharedPtrMessage *[nb_msgs];
msgs = new SrsMediaPacket *[nb_msgs];
}
SrsFastVector::~SrsFastVector()
@ -164,12 +164,12 @@ int SrsFastVector::end()
return count;
}
SrsSharedPtrMessage **SrsFastVector::data()
SrsMediaPacket **SrsFastVector::data()
{
return msgs;
}
SrsSharedPtrMessage *SrsFastVector::at(int index)
SrsMediaPacket *SrsFastVector::at(int index)
{
srs_assert(index < count);
return msgs[index];
@ -193,13 +193,13 @@ void SrsFastVector::erase(int _begin, int _end)
count -= _end - _begin;
}
void SrsFastVector::push_back(SrsSharedPtrMessage *msg)
void SrsFastVector::push_back(SrsMediaPacket *msg)
{
// increase vector.
if (count >= nb_msgs) {
int size = srs_max(SRS_PERF_MW_MSGS * 8, nb_msgs * 2);
SrsSharedPtrMessage **buf = msgs;
msgs = new SrsSharedPtrMessage *[size];
SrsMediaPacket **buf = msgs;
msgs = new SrsMediaPacket *[size];
for (int i = 0; i < nb_msgs; i++) {
msgs[i] = buf[i];
}
@ -216,7 +216,7 @@ void SrsFastVector::push_back(SrsSharedPtrMessage *msg)
void SrsFastVector::free()
{
for (int i = 0; i < count; i++) {
SrsSharedPtrMessage *msg = msgs[i];
SrsMediaPacket *msg = msgs[i];
srs_freep(msg);
}
count = 0;
@ -250,7 +250,7 @@ void SrsMessageQueue::set_queue_size(srs_utime_t queue_size)
max_queue_size = queue_size;
}
srs_error_t SrsMessageQueue::enqueue(SrsSharedPtrMessage *msg, bool *is_overflow)
srs_error_t SrsMessageQueue::enqueue(SrsMediaPacket *msg, bool *is_overflow)
{
srs_error_t err = srs_success;
@ -283,7 +283,7 @@ srs_error_t SrsMessageQueue::enqueue(SrsSharedPtrMessage *msg, bool *is_overflow
return err;
}
srs_error_t SrsMessageQueue::dump_packets(int max_count, SrsSharedPtrMessage **pmsgs, int &count)
srs_error_t SrsMessageQueue::dump_packets(int max_count, SrsMediaPacket **pmsgs, int &count)
{
srs_error_t err = srs_success;
@ -295,10 +295,10 @@ srs_error_t SrsMessageQueue::dump_packets(int max_count, SrsSharedPtrMessage **p
srs_assert(max_count > 0);
count = srs_min(max_count, nb_msgs);
SrsSharedPtrMessage **omsgs = msgs.data();
memcpy(pmsgs, omsgs, count * sizeof(SrsSharedPtrMessage *));
SrsMediaPacket **omsgs = msgs.data();
memcpy(pmsgs, omsgs, count * sizeof(SrsMediaPacket *));
SrsSharedPtrMessage *last = omsgs[count - 1];
SrsMediaPacket *last = omsgs[count - 1];
av_start_time = srs_utime_t(last->timestamp * SRS_UTIME_MILLISECONDS);
if (count >= nb_msgs) {
@ -324,9 +324,9 @@ srs_error_t SrsMessageQueue::dump_packets(SrsLiveConsumer *consumer, bool atc, S
return err;
}
SrsSharedPtrMessage **omsgs = msgs.data();
SrsMediaPacket **omsgs = msgs.data();
for (int i = 0; i < nb_msgs; i++) {
SrsSharedPtrMessage *msg = omsgs[i];
SrsMediaPacket *msg = omsgs[i];
if ((err = consumer->enqueue(msg, atc, ag)) != srs_success) {
return srs_error_wrap(err, "consume message");
}
@ -337,13 +337,13 @@ srs_error_t SrsMessageQueue::dump_packets(SrsLiveConsumer *consumer, bool atc, S
void SrsMessageQueue::shrink()
{
SrsSharedPtrMessage *video_sh = NULL;
SrsSharedPtrMessage *audio_sh = NULL;
SrsMediaPacket *video_sh = NULL;
SrsMediaPacket *audio_sh = NULL;
int msgs_size = (int)msgs.size();
// Remove all msgs, mark the sequence headers.
for (int i = 0; i < (int)msgs.size(); i++) {
SrsSharedPtrMessage *msg = msgs.at(i);
SrsMediaPacket *msg = msgs.at(i);
if (msg->is_video() && SrsFlvVideo::sh(msg->payload(), msg->size())) {
srs_freep(video_sh);
@ -380,10 +380,10 @@ void SrsMessageQueue::shrink()
void SrsMessageQueue::clear()
{
#ifndef SRS_PERF_QUEUE_FAST_VECTOR
std::vector<SrsSharedPtrMessage *>::iterator it;
std::vector<SrsMediaPacket *>::iterator it;
for (it = msgs.begin(); it != msgs.end(); ++it) {
SrsSharedPtrMessage *msg = *it;
SrsMediaPacket *msg = *it;
srs_freep(msg);
}
#else
@ -445,11 +445,11 @@ int64_t SrsLiveConsumer::get_time()
return jitter->get_time();
}
srs_error_t SrsLiveConsumer::enqueue(SrsSharedPtrMessage *shared_msg, bool atc, SrsRtmpJitterAlgorithm ag)
srs_error_t SrsLiveConsumer::enqueue(SrsMediaPacket *shared_msg, bool atc, SrsRtmpJitterAlgorithm ag)
{
srs_error_t err = srs_success;
SrsSharedPtrMessage *msg = shared_msg->copy();
SrsMediaPacket *msg = shared_msg->copy();
if (!atc) {
if ((err = jitter->correct(msg, ag)) != srs_success) {
@ -606,7 +606,7 @@ bool SrsGopCache::enabled()
return enable_gop_cache;
}
srs_error_t SrsGopCache::cache(SrsSharedPtrMessage *shared_msg)
srs_error_t SrsGopCache::cache(SrsMediaPacket *shared_msg)
{
srs_error_t err = srs_success;
@ -615,7 +615,7 @@ srs_error_t SrsGopCache::cache(SrsSharedPtrMessage *shared_msg)
}
// the gop cache know when to gop it.
SrsSharedPtrMessage *msg = shared_msg;
SrsMediaPacket *msg = shared_msg;
// got video, update the video count if acceptable
if (msg->is_video()) {
@ -669,9 +669,9 @@ srs_error_t SrsGopCache::cache(SrsSharedPtrMessage *shared_msg)
void SrsGopCache::clear()
{
std::vector<SrsSharedPtrMessage *>::iterator it;
std::vector<SrsMediaPacket *>::iterator it;
for (it = gop_cache.begin(); it != gop_cache.end(); ++it) {
SrsSharedPtrMessage *msg = *it;
SrsMediaPacket *msg = *it;
srs_freep(msg);
}
gop_cache.clear();
@ -684,9 +684,9 @@ srs_error_t SrsGopCache::dump(SrsLiveConsumer *consumer, bool atc, SrsRtmpJitter
{
srs_error_t err = srs_success;
std::vector<SrsSharedPtrMessage *>::iterator it;
std::vector<SrsMediaPacket *>::iterator it;
for (it = gop_cache.begin(); it != gop_cache.end(); ++it) {
SrsSharedPtrMessage *msg = *it;
SrsMediaPacket *msg = *it;
if ((err = consumer->enqueue(msg, atc, jitter_algorithm)) != srs_success) {
return srs_error_wrap(err, "enqueue message");
}
@ -707,7 +707,7 @@ srs_utime_t SrsGopCache::start_time()
return 0;
}
SrsSharedPtrMessage *msg = gop_cache[0];
SrsMediaPacket *msg = gop_cache[0];
srs_assert(msg);
return srs_utime_t(msg->timestamp * SRS_UTIME_MILLISECONDS);
@ -727,7 +727,7 @@ ISrsLiveSourceHandler::~ISrsLiveSourceHandler()
}
// TODO: FIXME: Remove it?
bool srs_hls_can_continue(int ret, SrsSharedPtrMessage *sh, SrsSharedPtrMessage *msg)
bool srs_hls_can_continue(int ret, SrsMediaPacket *sh, SrsMediaPacket *msg)
{
// only continue for decode error.
if (ret != ERROR_HLS_DECODE_ERROR) {
@ -758,9 +758,9 @@ SrsMixQueue::~SrsMixQueue()
void SrsMixQueue::clear()
{
std::multimap<int64_t, SrsSharedPtrMessage *>::iterator it;
std::multimap<int64_t, SrsMediaPacket *>::iterator it;
for (it = msgs.begin(); it != msgs.end(); ++it) {
SrsSharedPtrMessage *msg = it->second;
SrsMediaPacket *msg = it->second;
srs_freep(msg);
}
msgs.clear();
@ -769,7 +769,7 @@ void SrsMixQueue::clear()
nb_audios = 0;
}
void SrsMixQueue::push(SrsSharedPtrMessage *msg)
void SrsMixQueue::push(SrsMediaPacket *msg)
{
msgs.insert(std::make_pair(msg->timestamp, msg));
@ -780,7 +780,7 @@ void SrsMixQueue::push(SrsSharedPtrMessage *msg)
}
}
SrsSharedPtrMessage *SrsMixQueue::pop()
SrsMediaPacket *SrsMixQueue::pop()
{
bool mix_ok = false;
@ -804,8 +804,8 @@ SrsSharedPtrMessage *SrsMixQueue::pop()
}
// pop the first msg.
std::multimap<int64_t, SrsSharedPtrMessage *>::iterator it = msgs.begin();
SrsSharedPtrMessage *msg = it->second;
std::multimap<int64_t, SrsMediaPacket *>::iterator it = msgs.begin();
SrsMediaPacket *msg = it->second;
msgs.erase(it);
if (msg->is_video()) {
@ -920,7 +920,7 @@ srs_utime_t SrsOriginHub::cleanup_delay()
return srs_max(hls_delay, dash_delay);
}
srs_error_t SrsOriginHub::on_meta_data(SrsSharedPtrMessage *shared_metadata, SrsOnMetaDataPacket *packet)
srs_error_t SrsOriginHub::on_meta_data(SrsMediaPacket *shared_metadata, SrsOnMetaDataPacket *packet)
{
srs_error_t err = srs_success;
@ -942,11 +942,11 @@ srs_error_t SrsOriginHub::on_meta_data(SrsSharedPtrMessage *shared_metadata, Srs
return err;
}
srs_error_t SrsOriginHub::on_audio(SrsSharedPtrMessage *shared_audio)
srs_error_t SrsOriginHub::on_audio(SrsMediaPacket *shared_audio)
{
srs_error_t err = srs_success;
SrsSharedPtrMessage *msg = shared_audio;
SrsMediaPacket *msg = shared_audio;
SrsRtmpFormat *format = source_->format_;
// Handle the metadata when got sequence header.
@ -1028,11 +1028,11 @@ srs_error_t SrsOriginHub::on_audio(SrsSharedPtrMessage *shared_audio)
return err;
}
srs_error_t SrsOriginHub::on_video(SrsSharedPtrMessage *shared_video, bool is_sequence_header)
srs_error_t SrsOriginHub::on_video(SrsMediaPacket *shared_video, bool is_sequence_header)
{
srs_error_t err = srs_success;
SrsSharedPtrMessage *msg = shared_video;
SrsMediaPacket *msg = shared_video;
SrsRtmpFormat *format = source_->format_;
// cache the sequence header if h264
@ -1186,9 +1186,9 @@ srs_error_t SrsOriginHub::on_forwarder_start(SrsForwarder *forwarder)
{
srs_error_t err = srs_success;
SrsSharedPtrMessage *cache_metadata = source_->meta->data();
SrsSharedPtrMessage *cache_sh_video = source_->meta->vsh();
SrsSharedPtrMessage *cache_sh_audio = source_->meta->ash();
SrsMediaPacket *cache_metadata = source_->meta->data();
SrsMediaPacket *cache_sh_video = source_->meta->vsh();
SrsMediaPacket *cache_sh_audio = source_->meta->ash();
// feed the forwarder the metadata/sequence header,
// when reload to enable the forwarder.
@ -1209,9 +1209,9 @@ srs_error_t SrsOriginHub::on_dvr_request_sh()
{
srs_error_t err = srs_success;
SrsSharedPtrMessage *cache_metadata = source_->meta->data();
SrsSharedPtrMessage *cache_sh_video = source_->meta->vsh();
SrsSharedPtrMessage *cache_sh_audio = source_->meta->ash();
SrsMediaPacket *cache_metadata = source_->meta->data();
SrsMediaPacket *cache_sh_video = source_->meta->vsh();
SrsMediaPacket *cache_sh_audio = source_->meta->ash();
// feed the dvr the metadata/sequence header,
// when reload to start dvr, dvr will never get the sequence header in stream,
@ -1239,14 +1239,14 @@ srs_error_t SrsOriginHub::on_hls_request_sh()
{
srs_error_t err = srs_success;
SrsSharedPtrMessage *cache_sh_video = source_->meta->vsh();
SrsMediaPacket *cache_sh_video = source_->meta->vsh();
if (cache_sh_video) {
if ((err = hls->on_video(cache_sh_video, source_->meta->vsh_format())) != srs_success) {
return srs_error_wrap(err, "hls video");
}
}
SrsSharedPtrMessage *cache_sh_audio = source_->meta->ash();
SrsMediaPacket *cache_sh_audio = source_->meta->ash();
if (cache_sh_audio) {
if ((err = hls->on_audio(cache_sh_audio, source_->meta->ash_format())) != srs_success) {
return srs_error_wrap(err, "hls audio");
@ -1399,12 +1399,12 @@ void SrsMetaCache::clear()
srs_freep(audio);
}
SrsSharedPtrMessage *SrsMetaCache::data()
SrsMediaPacket *SrsMetaCache::data()
{
return meta;
}
SrsSharedPtrMessage *SrsMetaCache::vsh()
SrsMediaPacket *SrsMetaCache::vsh()
{
return video;
}
@ -1414,7 +1414,7 @@ SrsFormat *SrsMetaCache::vsh_format()
return vformat;
}
SrsSharedPtrMessage *SrsMetaCache::ash()
SrsMediaPacket *SrsMetaCache::ash()
{
return audio;
}
@ -1448,12 +1448,12 @@ srs_error_t SrsMetaCache::dumps(SrsLiveConsumer *consumer, bool atc, SrsRtmpJitt
return err;
}
SrsSharedPtrMessage *SrsMetaCache::previous_vsh()
SrsMediaPacket *SrsMetaCache::previous_vsh()
{
return previous_video;
}
SrsSharedPtrMessage *SrsMetaCache::previous_ash()
SrsMediaPacket *SrsMetaCache::previous_ash()
{
return previous_audio;
}
@ -1520,19 +1520,21 @@ srs_error_t SrsMetaCache::update_data(SrsMessageHeader *header, SrsOnMetaDataPac
// create a shared ptr message.
srs_freep(meta);
meta = new SrsSharedPtrMessage();
meta = new SrsMediaPacket();
updated = true;
// dump message to shared ptr message.
// the payload/size managed by cache_metadata, user should not free it.
if ((err = meta->create(header, payload, size)) != srs_success) {
SrsCommonMessage common_msg;
if ((err = common_msg.create(header, payload, size)) != srs_success) {
return srs_error_wrap(err, "create metadata");
}
common_msg.to_msg(meta);
return err;
}
srs_error_t SrsMetaCache::update_ash(SrsSharedPtrMessage *msg)
srs_error_t SrsMetaCache::update_ash(SrsMediaPacket *msg)
{
srs_freep(audio);
audio = msg->copy();
@ -1540,7 +1542,7 @@ srs_error_t SrsMetaCache::update_ash(SrsSharedPtrMessage *msg)
return aformat->on_audio(msg);
}
srs_error_t SrsMetaCache::update_vsh(SrsSharedPtrMessage *msg)
srs_error_t SrsMetaCache::update_vsh(SrsMediaPacket *msg)
{
srs_freep(video);
video = msg->copy();
@ -1962,7 +1964,6 @@ srs_error_t SrsLiveSource::on_meta_data(SrsCommonMessage *msg, SrsOnMetaDataPack
srs_error_t SrsLiveSource::on_audio(SrsCommonMessage *shared_audio)
{
srs_error_t err = srs_success;
// Detect where stream is monotonically increasing.
if (!mix_correct && is_monotonically_increase) {
@ -1976,15 +1977,13 @@ srs_error_t SrsLiveSource::on_audio(SrsCommonMessage *shared_audio)
// convert shared_audio to msg, user should not use shared_audio again.
// the payload is transfer to msg, and set to NULL in shared_audio.
SrsSharedPtrMessage msg;
if ((err = msg.create(shared_audio)) != srs_success) {
return srs_error_wrap(err, "create message");
}
SrsMediaPacket msg;
shared_audio->to_msg(&msg);
return on_frame(&msg);
}
srs_error_t SrsLiveSource::on_frame(SrsSharedPtrMessage *msg)
srs_error_t SrsLiveSource::on_frame(SrsMediaPacket *msg)
{
srs_error_t err = srs_success;
@ -2001,7 +2000,7 @@ srs_error_t SrsLiveSource::on_frame(SrsSharedPtrMessage *msg)
mix_queue->push(msg->copy());
// fetch someone from mix queue.
SrsSharedPtrMessage *m = mix_queue->pop();
SrsMediaPacket *m = mix_queue->pop();
if (!m) {
return err;
}
@ -2017,7 +2016,7 @@ srs_error_t SrsLiveSource::on_frame(SrsSharedPtrMessage *msg)
return err;
}
srs_error_t SrsLiveSource::on_audio_imp(SrsSharedPtrMessage *msg)
srs_error_t SrsLiveSource::on_audio_imp(SrsMediaPacket *msg)
{
srs_error_t err = srs_success;
@ -2122,15 +2121,13 @@ srs_error_t SrsLiveSource::on_video(SrsCommonMessage *shared_video)
// convert shared_video to msg, user should not use shared_video again.
// the payload is transfer to msg, and set to NULL in shared_video.
SrsSharedPtrMessage msg;
if ((err = msg.create(shared_video)) != srs_success) {
return srs_error_wrap(err, "create message");
}
SrsMediaPacket msg;
shared_video->to_msg(&msg);
return on_frame(&msg);
}
srs_error_t SrsLiveSource::on_video_imp(SrsSharedPtrMessage *msg)
srs_error_t SrsLiveSource::on_video_imp(SrsMediaPacket *msg)
{
srs_error_t err = srs_success;
@ -2271,7 +2268,6 @@ srs_error_t SrsLiveSource::on_aggregate(SrsCommonMessage *msg)
o.header.timestamp_delta = timestamp;
o.header.timestamp = timestamp;
o.header.stream_id = stream_id;
o.header.prefer_cid = msg->header.prefer_cid;
if (data_size > 0) {
o.create_payload(data_size);

72
trunk/src/app/srs_app_source.hpp
View File

@ -29,7 +29,7 @@ class SrsPublishEdge;
class SrsLiveSource;
class SrsCommonMessage;
class SrsOnMetaDataPacket;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsForwarder;
class ISrsRequest;
class SrsStSocket;
@ -73,7 +73,7 @@ public:
public:
// detect the time jitter and correct it.
// @param ag the algorithm to use for time jitter.
virtual srs_error_t correct(SrsSharedPtrMessage *msg, SrsRtmpJitterAlgorithm ag);
virtual srs_error_t correct(SrsMediaPacket *msg, SrsRtmpJitterAlgorithm ag);
// Get current client time, the last packet time.
virtual int64_t get_time();
};
@ -83,7 +83,7 @@ public:
class SrsFastVector
{
private:
SrsSharedPtrMessage **msgs;
SrsMediaPacket **msgs;
int nb_msgs;
int count;
@ -95,11 +95,11 @@ public:
virtual int size();
virtual int begin();
virtual int end();
virtual SrsSharedPtrMessage **data();
virtual SrsSharedPtrMessage *at(int index);
virtual SrsMediaPacket **data();
virtual SrsMediaPacket *at(int index);
virtual void clear();
virtual void erase(int _begin, int _end);
virtual void push_back(SrsSharedPtrMessage *msg);
virtual void push_back(SrsMediaPacket *msg);
virtual void free();
};
#endif
@ -121,7 +121,7 @@ private:
#ifdef SRS_PERF_QUEUE_FAST_VECTOR
SrsFastVector msgs;
#else
std::vector<SrsSharedPtrMessage *> msgs;
std::vector<SrsMediaPacket *> msgs;
#endif
public:
SrsMessageQueue(bool ignore_shrink = false);
@ -140,12 +140,12 @@ public:
// Enqueue the message, the timestamp always monotonically.
// @param msg, the msg to enqueue, user never free it whatever the return code.
// @param is_overflow, whether overflow and shrinked. NULL to ignore.
virtual srs_error_t enqueue(SrsSharedPtrMessage *msg, bool *is_overflow = NULL);
virtual srs_error_t enqueue(SrsMediaPacket *msg, bool *is_overflow = NULL);
// Get packets in consumer queue.
// @pmsgs SrsSharedPtrMessage*[], used to store the msgs, user must alloc it.
// @pmsgs SrsMediaPacket*[], used to store the msgs, user must alloc it.
// @count the count in array, output param.
// @max_count the max count to dequeue, must be positive.
virtual srs_error_t dump_packets(int max_count, SrsSharedPtrMessage **pmsgs, int &count);
virtual srs_error_t dump_packets(int max_count, SrsMediaPacket **pmsgs, int &count);
// Dumps packets to consumer, use specified args.
// @remark the atc/tba/tbv/ag are same to SrsLiveConsumer.enqueue().
virtual srs_error_t dump_packets(SrsLiveConsumer *consumer, bool atc, SrsRtmpJitterAlgorithm ag);
@ -212,7 +212,7 @@ public:
// @param shared_msg, directly ptr, copy it if need to save it.
// @param whether atc, donot use jitter correct if true.
// @param ag the algorithm of time jitter.
virtual srs_error_t enqueue(SrsSharedPtrMessage *shared_msg, bool atc, SrsRtmpJitterAlgorithm ag);
virtual srs_error_t enqueue(SrsMediaPacket *shared_msg, bool atc, SrsRtmpJitterAlgorithm ag);
// Get packets in consumer queue.
// @param msgs the msgs array to dump packets to send.
// @param count the count in array, intput and output param.
@ -262,7 +262,7 @@ private:
// @see: https://github.com/ossrs/srs/issues/124
int audio_after_last_video_count;
// cached gop.
std::vector<SrsSharedPtrMessage *> gop_cache;
std::vector<SrsMediaPacket *> gop_cache;
public:
SrsGopCache();
@ -279,7 +279,7 @@ public:
// 1. cache the gop when got h264 video packet.
// 2. clear gop when got keyframe.
// @param shared_msg, directly ptr, copy it if need to save it.
virtual srs_error_t cache(SrsSharedPtrMessage *shared_msg);
virtual srs_error_t cache(SrsMediaPacket *shared_msg);
// clear the gop cache.
virtual void clear();
// dump the cached gop to consumer.
@ -317,7 +317,7 @@ class SrsMixQueue
private:
uint32_t nb_videos;
uint32_t nb_audios;
std::multimap<int64_t, SrsSharedPtrMessage *> msgs;
std::multimap<int64_t, SrsMediaPacket *> msgs;
public:
SrsMixQueue();
@ -325,8 +325,8 @@ public:
public:
virtual void clear();
virtual void push(SrsSharedPtrMessage *msg);
virtual SrsSharedPtrMessage *pop();
virtual void push(SrsMediaPacket *msg);
virtual SrsMediaPacket *pop();
};
// The hub for origin is a collection of utilities for origin only,
@ -381,11 +381,11 @@ public:
public:
// When got a parsed metadata.
virtual srs_error_t on_meta_data(SrsSharedPtrMessage *shared_metadata, SrsOnMetaDataPacket *packet);
virtual srs_error_t on_meta_data(SrsMediaPacket *shared_metadata, SrsOnMetaDataPacket *packet);
// When got a parsed audio packet.
virtual srs_error_t on_audio(SrsSharedPtrMessage *shared_audio);
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio);
// When got a parsed video packet.
virtual srs_error_t on_video(SrsSharedPtrMessage *shared_video, bool is_sequence_header);
virtual srs_error_t on_video(SrsMediaPacket *shared_video, bool is_sequence_header);
public:
// When start publish stream.
@ -413,13 +413,13 @@ class SrsMetaCache
{
private:
// The cached metadata, FLV script data tag.
SrsSharedPtrMessage *meta;
SrsMediaPacket *meta;
// The cached video sequence header, for example, sps/pps for h.264.
SrsSharedPtrMessage *video;
SrsSharedPtrMessage *previous_video;
SrsMediaPacket *video;
SrsMediaPacket *previous_video;
// The cached audio sequence header, for example, asc for aac.
SrsSharedPtrMessage *audio;
SrsSharedPtrMessage *previous_audio;
SrsMediaPacket *audio;
SrsMediaPacket *previous_audio;
// The format for sequence header.
SrsRtmpFormat *vformat;
SrsRtmpFormat *aformat;
@ -436,12 +436,12 @@ public:
public:
// Get the cached metadata.
virtual SrsSharedPtrMessage *data();
virtual SrsMediaPacket *data();
// Get the cached vsh(video sequence header).
virtual SrsSharedPtrMessage *vsh();
virtual SrsMediaPacket *vsh();
virtual SrsFormat *vsh_format();
// Get the cached ash(audio sequence header).
virtual SrsSharedPtrMessage *ash();
virtual SrsMediaPacket *ash();
virtual SrsFormat *ash_format();
// Dumps cached metadata to consumer.
// @param dm Whether dumps the metadata.
@ -450,8 +450,8 @@ public:
public:
// Previous exists sequence header.
virtual SrsSharedPtrMessage *previous_vsh();
virtual SrsSharedPtrMessage *previous_ash();
virtual SrsMediaPacket *previous_vsh();
virtual SrsMediaPacket *previous_ash();
// Update previous sequence header, drop old one, set to new sequence header.
virtual void update_previous_vsh();
virtual void update_previous_ash();
@ -460,9 +460,9 @@ public:
// Update the cached metadata by packet.
virtual srs_error_t update_data(SrsMessageHeader *header, SrsOnMetaDataPacket *metadata, bool &updated);
// Update the cached audio sequence header.
virtual srs_error_t update_ash(SrsSharedPtrMessage *msg);
virtual srs_error_t update_ash(SrsMediaPacket *msg);
// Update the cached video sequence header.
virtual srs_error_t update_vsh(SrsSharedPtrMessage *msg);
virtual srs_error_t update_vsh(SrsMediaPacket *msg);
};
// The source manager to create and refresh all stream sources.
@ -595,19 +595,19 @@ public:
virtual srs_error_t on_meta_data(SrsCommonMessage *msg, SrsOnMetaDataPacket *metadata);
public:
// TODO: FIXME: Use SrsSharedPtrMessage instead.
// TODO: FIXME: Use SrsMediaPacket instead.
virtual srs_error_t on_audio(SrsCommonMessage *audio);
srs_error_t on_frame(SrsSharedPtrMessage *msg);
srs_error_t on_frame(SrsMediaPacket *msg);
private:
virtual srs_error_t on_audio_imp(SrsSharedPtrMessage *audio);
virtual srs_error_t on_audio_imp(SrsMediaPacket *audio);
public:
// TODO: FIXME: Use SrsSharedPtrMessage instead.
// TODO: FIXME: Use SrsMediaPacket instead.
virtual srs_error_t on_video(SrsCommonMessage *video);
private:
virtual srs_error_t on_video_imp(SrsSharedPtrMessage *video);
virtual srs_error_t on_video_imp(SrsMediaPacket *video);
public:
virtual srs_error_t on_aggregate(SrsCommonMessage *msg);

42
trunk/src/app/srs_app_srt_source.cpp
View File

@ -46,7 +46,7 @@ char *SrsSrtPacket::wrap(int size)
// Create a large enough message, with under-layer buffer.
srs_freep(shared_buffer_);
shared_buffer_ = new SrsSharedPtrMessage();
shared_buffer_ = new SrsMediaPacket();
char *buf = new char[size];
shared_buffer_->wrap(buf, size);
@ -61,7 +61,7 @@ char *SrsSrtPacket::wrap(char *data, int size)
return buf;
}
char *SrsSrtPacket::wrap(SrsSharedPtrMessage *msg)
char *SrsSrtPacket::wrap(SrsMediaPacket *msg)
{
// Generally, the wrap(msg) is used for RTMP to SRT, where the msg
// is not generated by SRT.
@ -79,7 +79,7 @@ SrsSrtPacket *SrsSrtPacket::copy()
{
SrsSrtPacket *cp = new SrsSrtPacket();
cp->shared_buffer_ = shared_buffer_ ? shared_buffer_->copy2() : NULL;
cp->shared_buffer_ = shared_buffer_ ? shared_buffer_->copy() : NULL;
cp->actual_buffer_size_ = actual_buffer_size_;
return cp;
@ -507,10 +507,8 @@ srs_error_t SrsSrtFrameBuilder::check_sps_pps_change(SrsTsMessage *msg)
return srs_error_wrap(err, "create rtmp");
}
SrsSharedPtrMessage frame;
if ((err = frame.create(&rtmp)) != srs_success) {
return srs_error_wrap(err, "create frame");
}
SrsMediaPacket frame;
rtmp.to_msg(&frame);
if ((err = bridge_->on_frame(&frame)) != srs_success) {
return srs_error_wrap(err, "srt to rtmp sps/pps");
@ -567,10 +565,8 @@ srs_error_t SrsSrtFrameBuilder::on_h264_frame(SrsTsMessage *msg, vector<pair<cha
payload.write_bytes(nal, nal_size);
}
SrsSharedPtrMessage frame;
if ((err = frame.create(&rtmp)) != srs_success) {
return srs_error_wrap(err, "create frame");
}
SrsMediaPacket frame;
rtmp.to_msg(&frame);
if ((err = bridge_->on_frame(&frame)) != srs_success) {
return srs_error_wrap(err, "srt ts video to rtmp");
@ -697,10 +693,8 @@ srs_error_t SrsSrtFrameBuilder::check_vps_sps_pps_change(SrsTsMessage *msg)
return srs_error_wrap(err, "create rtmp");
}
SrsSharedPtrMessage frame;
if ((err = frame.create(&rtmp)) != srs_success) {
return srs_error_wrap(err, "create frame");
}
SrsMediaPacket frame;
rtmp.to_msg(&frame);
if ((err = bridge_->on_frame(&frame)) != srs_success) {
return srs_error_wrap(err, "srt to rtmp vps/sps/pps");
@ -764,10 +758,8 @@ srs_error_t SrsSrtFrameBuilder::on_hevc_frame(SrsTsMessage *msg, vector<pair<cha
payload.write_bytes(nal, nal_size);
}
SrsSharedPtrMessage frame;
if ((err = frame.create(&rtmp)) != srs_success) {
return srs_error_wrap(err, "create frame");
}
SrsMediaPacket frame;
rtmp.to_msg(&frame);
if ((err = bridge_->on_frame(&frame)) != srs_success) {
return srs_error_wrap(err, "srt ts hevc video to rtmp");
@ -880,10 +872,8 @@ srs_error_t SrsSrtFrameBuilder::check_audio_sh_change(SrsTsMessage *msg, uint32_
stream.write_1bytes(0);
stream.write_bytes((char *)audio_sh_.data(), audio_sh_.size());
SrsSharedPtrMessage frame;
if ((err = frame.create(&rtmp)) != srs_success) {
return srs_error_wrap(err, "create frame");
}
SrsMediaPacket frame;
rtmp.to_msg(&frame);
if ((err = bridge_->on_frame(&frame)) != srs_success) {
return srs_error_wrap(err, "srt to rtmp audio sh");
@ -910,10 +900,8 @@ srs_error_t SrsSrtFrameBuilder::on_aac_frame(SrsTsMessage *msg, uint32_t pts, ch
// Write audio frame.
stream.write_bytes(data, data_size);
SrsSharedPtrMessage frame;
if ((err = frame.create(&rtmp)) != srs_success) {
return srs_error_wrap(err, "create frame");
}
SrsMediaPacket frame;
rtmp.to_msg(&frame);
if ((err = bridge_->on_frame(&frame)) != srs_success) {
return srs_error_wrap(err, "srt to rtmp audio sh");

6
trunk/src/app/srs_app_srt_source.hpp
View File

@ -18,7 +18,7 @@
#include <srs_kernel_ts.hpp>
#include <srs_protocol_st.hpp>
class SrsSharedPtrMessage;
class SrsMediaPacket;
class ISrsRequest;
class SrsLiveSource;
class SrsSrtSource;
@ -37,7 +37,7 @@ public:
char *wrap(int size);
char *wrap(char *data, int size);
// Wrap the shared message, we copy it.
char *wrap(SrsSharedPtrMessage *msg);
char *wrap(SrsMediaPacket *msg);
// Copy the SRT packet.
virtual SrsSrtPacket *copy();
@ -46,7 +46,7 @@ public:
int size();
private:
SrsSharedPtrMessage *shared_buffer_;
SrsMediaPacket *shared_buffer_;
// The size of SRT packet or SRT payload.
int actual_buffer_size_;
};

8
trunk/src/app/srs_app_stream_bridge.cpp
View File

@ -60,7 +60,7 @@ void SrsFrameToRtmpBridge::on_unpublish()
source_->on_unpublish();
}
srs_error_t SrsFrameToRtmpBridge::on_frame(SrsSharedPtrMessage *frame)
srs_error_t SrsFrameToRtmpBridge::on_frame(SrsMediaPacket *frame)
{
return source_->on_frame(frame);
}
@ -120,7 +120,7 @@ void SrsFrameToRtcBridge::on_unpublish()
source_->on_unpublish();
}
srs_error_t SrsFrameToRtcBridge::on_frame(SrsSharedPtrMessage *frame)
srs_error_t SrsFrameToRtcBridge::on_frame(SrsMediaPacket *frame)
{
#ifdef SRS_FFMPEG_FIT
return rtp_builder_->on_frame(frame);
@ -178,7 +178,7 @@ void SrsFrameToRtspBridge::on_unpublish()
source_->on_unpublish();
}
srs_error_t SrsFrameToRtspBridge::on_frame(SrsSharedPtrMessage *frame)
srs_error_t SrsFrameToRtspBridge::on_frame(SrsMediaPacket *frame)
{
return rtp_builder_->on_frame(frame);
}
@ -237,7 +237,7 @@ void SrsCompositeBridge::on_unpublish()
}
}
srs_error_t SrsCompositeBridge::on_frame(SrsSharedPtrMessage *frame)
srs_error_t SrsCompositeBridge::on_frame(SrsMediaPacket *frame)
{
srs_error_t err = srs_success;

12
trunk/src/app/srs_app_stream_bridge.hpp
View File

@ -15,7 +15,7 @@
#include <vector>
class ISrsRequest;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsLiveSource;
class SrsRtcSource;
class SrsRtmpFormat;
@ -37,7 +37,7 @@ public:
public:
virtual srs_error_t initialize(ISrsRequest *r) = 0;
virtual srs_error_t on_publish() = 0;
virtual srs_error_t on_frame(SrsSharedPtrMessage *frame) = 0;
virtual srs_error_t on_frame(SrsMediaPacket *frame) = 0;
virtual void on_unpublish() = 0;
};
@ -59,7 +59,7 @@ public:
virtual void on_unpublish();
public:
virtual srs_error_t on_frame(SrsSharedPtrMessage *frame);
virtual srs_error_t on_frame(SrsMediaPacket *frame);
};
// A bridge to covert AV frame to WebRTC stream.
@ -80,7 +80,7 @@ public:
virtual srs_error_t initialize(ISrsRequest *r);
virtual srs_error_t on_publish();
virtual void on_unpublish();
virtual srs_error_t on_frame(SrsSharedPtrMessage *frame);
virtual srs_error_t on_frame(SrsMediaPacket *frame);
srs_error_t on_rtp(SrsRtpPacket *pkt);
};
@ -102,7 +102,7 @@ public:
virtual srs_error_t initialize(ISrsRequest *r);
virtual srs_error_t on_publish();
virtual void on_unpublish();
virtual srs_error_t on_frame(SrsSharedPtrMessage *frame);
virtual srs_error_t on_frame(SrsMediaPacket *frame);
srs_error_t on_rtp(SrsRtpPacket *pkt);
};
#endif
@ -124,7 +124,7 @@ public:
virtual void on_unpublish();
public:
virtual srs_error_t on_frame(SrsSharedPtrMessage *frame);
virtual srs_error_t on_frame(SrsMediaPacket *frame);
public:
SrsCompositeBridge *append(ISrsStreamBridge *bridge);

2
trunk/src/core/srs_core_version7.hpp
View File

@ -9,6 +9,6 @@
#define VERSION_MAJOR 7
#define VERSION_MINOR 0
#define VERSION_REVISION 73
#define VERSION_REVISION 74
#endif

2373
trunk/src/kernel/srs_kernel_codec.cpp
View File

File diff suppressed because it is too large Load Diff

206
trunk/src/kernel/srs_kernel_codec.hpp
View File

@ -12,6 +12,9 @@
#include <string>
#include <vector>
#include <srs_core_autofree.hpp>
#include <srs_kernel_buffer.hpp>
class SrsBuffer;
class SrsBitBuffer;
class SrsFormat;
@ -264,6 +267,8 @@ enum SrsFrameType {
SrsFrameTypeVideo = 9,
// 18 = script data
SrsFrameTypeScript = 18,
// 20 = command data
SrsFrameTypeCommand = 20,
};
/**
@ -1107,30 +1112,6 @@ enum SrsHevcLevel {
};
std::string srs_hevc_level2str(SrsHevcLevel level);
/**
* A sample is the unit of frame.
* It's a NALU for H.264, H.265.
* It's the whole AAC raw data for AAC.
* @remark Neither SPS/PPS or ASC is sample unit, it's codec sequence header.
*/
class SrsSample
{
public:
// The size of unit.
int size;
// The ptr of unit, user must free it.
char *bytes;
public:
SrsSample();
SrsSample(char *b, int s);
~SrsSample();
public:
// Copy sample, share the bytes pointer.
SrsSample *copy();
};
/**
* The codec is the information of encoder,
* corresponding to the sequence header of FLV,
@ -1248,183 +1229,6 @@ public:
virtual bool is_avc_codec_ok();
};
// A frame, consists of a codec and a group of samples.
// TODO: FIXME: Rename to packet to follow names of FFmpeg, which means before decoding or after decoding.
class SrsFrame
{
public:
// The DTS/PTS in milliseconds, which is TBN=1000.
int64_t dts;
// PTS = DTS + CTS.
int32_t cts;
public:
// The codec info of frame.
SrsCodecConfig *codec;
// The actual parsed number of samples.
int nb_samples;
// The sampels cache.
SrsSample samples[SrsMaxNbSamples];
public:
SrsFrame();
virtual ~SrsFrame();
public:
// Initialize the frame, to parse sampels.
virtual srs_error_t initialize(SrsCodecConfig *c);
// Add a sample to frame.
virtual srs_error_t add_sample(char *bytes, int size);
};
// A audio frame, besides a frame, contains the audio frame info, such as frame type.
// TODO: FIXME: Rename to packet to follow names of FFmpeg, which means before decoding or after decoding.
class SrsAudioFrame : public SrsFrame
{
public:
SrsAudioAacFrameTrait aac_packet_type;
public:
SrsAudioFrame();
virtual ~SrsAudioFrame();
public:
virtual SrsAudioCodecConfig *acodec();
};
// A video frame, besides a frame, contains the video frame info, such as frame type.
// TODO: FIXME: Rename to packet to follow names of FFmpeg, which means before decoding or after decoding.
class SrsVideoFrame : public SrsFrame
{
public:
// video specified
SrsVideoAvcFrameType frame_type;
SrsVideoAvcFrameTrait avc_packet_type;
// whether sample_units contains IDR frame.
bool has_idr;
// Whether exists AUD NALU.
bool has_aud;
// Whether exists SPS/PPS NALU.
bool has_sps_pps;
// The first nalu type.
SrsAvcNaluType first_nalu_type;
public:
SrsVideoFrame();
virtual ~SrsVideoFrame();
public:
// Initialize the frame, to parse sampels.
virtual srs_error_t initialize(SrsCodecConfig *c);
// Add the sample without ANNEXB or IBMF header, or RAW AAC or MP3 data.
virtual srs_error_t add_sample(char *bytes, int size);
public:
virtual SrsVideoCodecConfig *vcodec();
public:
static srs_error_t parse_avc_nalu_type(const SrsSample *sample, SrsAvcNaluType &avc_nalu_type);
static srs_error_t parse_avc_bframe(const SrsSample *sample, bool &is_b_frame);
static srs_error_t parse_hevc_nalu_type(const SrsSample *sample, SrsHevcNaluType &hevc_nalu_type);
static srs_error_t parse_hevc_bframe(const SrsSample *sample, SrsFormat *format, bool &is_b_frame);
};
/**
* A codec format, including one or many stream, each stream identified by a frame.
* For example, a typical RTMP stream format, consits of a video and audio frame.
* Maybe some RTMP stream only has a audio stream, for instance, redio application.
*/
class SrsFormat
{
public:
SrsAudioFrame *audio;
SrsAudioCodecConfig *acodec;
SrsVideoFrame *video;
SrsVideoCodecConfig *vcodec;
public:
char *raw;
int nb_raw;
public:
// for sequence header, whether parse the h.264 sps.
// TODO: FIXME: Refine it.
bool avc_parse_sps;
// Whether try to parse in ANNEXB, then by IBMF.
bool try_annexb_first;
public:
SrsFormat();
virtual ~SrsFormat();
public:
// Initialize the format.
virtual srs_error_t initialize();
// When got a parsed audio packet.
// @param data The data in FLV format.
virtual srs_error_t on_audio(int64_t timestamp, char *data, int size);
// When got a parsed video packet.
// @param data The data in FLV format.
virtual srs_error_t on_video(int64_t timestamp, char *data, int size);
// When got a audio aac sequence header.
virtual srs_error_t on_aac_sequence_header(char *data, int size);
public:
virtual bool is_aac_sequence_header();
virtual bool is_mp3_sequence_header();
// TODO: is avc|hevc|av1 sequence header
virtual bool is_avc_sequence_header();
private:
// Demux the video packet in H.264 codec.
// The packet is muxed in FLV format, defined in flv specification.
// Demux the sps/pps from sequence header.
// Demux the samples from NALUs.
virtual srs_error_t video_avc_demux(SrsBuffer *stream, int64_t timestamp);
private:
virtual srs_error_t hevc_demux_hvcc(SrsBuffer *stream);
private:
virtual srs_error_t hevc_demux_vps_sps_pps(SrsHevcHvccNalu *nal);
virtual srs_error_t hevc_demux_vps_rbsp(char *rbsp, int nb_rbsp);
virtual srs_error_t hevc_demux_sps_rbsp(char *rbsp, int nb_rbsp);
virtual srs_error_t hevc_demux_pps_rbsp(char *rbsp, int nb_rbsp);
virtual srs_error_t hevc_demux_rbsp_ptl(SrsBitBuffer *bs, SrsHevcProfileTierLevel *ptl, int profile_present_flag, int max_sub_layers_minus1);
public:
virtual srs_error_t hevc_demux_vps(SrsBuffer *stream);
virtual srs_error_t hevc_demux_sps(SrsBuffer *stream);
virtual srs_error_t hevc_demux_pps(SrsBuffer *stream);
private:
// Parse the H.264 SPS/PPS.
virtual srs_error_t avc_demux_sps_pps(SrsBuffer *stream);
virtual srs_error_t avc_demux_sps();
virtual srs_error_t avc_demux_sps_rbsp(char *rbsp, int nb_rbsp);
private:
// Parse the H.264 or H.265 NALUs.
virtual srs_error_t video_nalu_demux(SrsBuffer *stream);
// Demux the avc NALU in "AnnexB" from ISO_IEC_14496-10-AVC-2003.pdf, page 211.
virtual srs_error_t avc_demux_annexb_format(SrsBuffer *stream);
virtual srs_error_t do_avc_demux_annexb_format(SrsBuffer *stream);
// Demux the avc NALU in "ISO Base Media File Format" from ISO_IEC_14496-15-AVC-format-2012.pdf, page 20
virtual srs_error_t avc_demux_ibmf_format(SrsBuffer *stream);
virtual srs_error_t do_avc_demux_ibmf_format(SrsBuffer *stream);
private:
// Demux the audio packet in AAC codec.
// Demux the asc from sequence header.
// Demux the sampels from RAW data.
virtual srs_error_t audio_aac_demux(SrsBuffer *stream, int64_t timestamp);
virtual srs_error_t audio_mp3_demux(SrsBuffer *stream, int64_t timestamp, bool fresh);
public:
// Directly demux the sequence header, without RTMP packet header.
virtual srs_error_t audio_aac_sequence_header_demux(char *data, int size);
};
// To read H.264 NALU uev.
extern srs_error_t srs_avc_nalu_read_uev(SrsBitBuffer *stream, int32_t &v);
extern srs_error_t srs_avc_nalu_read_bit(SrsBitBuffer *stream, int8_t &v);

178
trunk/src/kernel/srs_kernel_flv.cpp
View File

@ -20,13 +20,48 @@ using namespace std;
#include <srs_kernel_codec.hpp>
#include <srs_kernel_error.hpp>
#include <srs_kernel_file.hpp>
#include <srs_kernel_kbps.hpp>
#include <srs_kernel_log.hpp>
#include <srs_kernel_rtc_rtp.hpp>
#include <srs_kernel_utility.hpp>
#include <srs_kernel_kbps.hpp>
int srs_rtmp_prefer_cid(SrsFrameType message_type)
{
if (message_type == SrsFrameTypeVideo) {
return RTMP_CID_Video;
} else if (message_type == SrsFrameTypeAudio) {
return RTMP_CID_Audio;
} else if (message_type == SrsFrameTypeCommand || message_type == SrsFrameTypeScript) {
return RTMP_CID_OverStream;
} else if (message_type == (SrsFrameType)RTMP_MSG_AMF0CommandMessage) {
return RTMP_CID_OverStream;
} else if (message_type == (SrsFrameType)RTMP_MSG_AMF3DataMessage) {
return RTMP_CID_OverStream;
} else {
return RTMP_CID_OverConnection;
}
}
SrsPps *_srs_pps_objs_msgs = NULL;
int srs_rtmp_write_chunk_header(SrsMediaPacket *msg, char *cache, int nb_cache, bool c0)
{
int payload_length = msg->payload_.get() ? msg->payload_->size() : 0;
int chunk_id = srs_rtmp_prefer_cid(msg->message_type);
if (c0) {
return srs_chunk_header_c0(chunk_id,
(uint32_t)msg->timestamp,
payload_length,
msg->message_type,
msg->stream_id,
cache,
nb_cache);
} else {
return srs_chunk_header_c3(chunk_id,
(uint32_t)msg->timestamp,
cache,
nb_cache);
}
}
int srs_chunk_header_c0(int prefer_cid, uint32_t timestamp, int32_t payload_length, int8_t message_type, int32_t stream_id, char *cache, int nb_cache)
{
@ -159,8 +194,6 @@ SrsMessageHeader::SrsMessageHeader()
stream_id = 0;
timestamp = 0;
// we always use the connection chunk-id
prefer_cid = RTMP_CID_OverConnection;
}
SrsMessageHeader::~SrsMessageHeader()
@ -234,9 +267,6 @@ void SrsMessageHeader::initialize_amf0_script(int size, int stream)
timestamp_delta = (int32_t)0;
timestamp = (int64_t)0;
stream_id = (int32_t)stream;
// amf0 script use connection2 chunk-id
prefer_cid = RTMP_CID_OverConnection2;
}
void SrsMessageHeader::initialize_audio(int size, uint32_t time, int stream)
@ -246,9 +276,6 @@ void SrsMessageHeader::initialize_audio(int size, uint32_t time, int stream)
timestamp_delta = (int32_t)time;
timestamp = (int64_t)time;
stream_id = (int32_t)stream;
// audio chunk-id
prefer_cid = RTMP_CID_Audio;
}
void SrsMessageHeader::initialize_video(int size, uint32_t time, int stream)
@ -258,9 +285,6 @@ void SrsMessageHeader::initialize_video(int size, uint32_t time, int stream)
timestamp_delta = (int32_t)time;
timestamp = (int64_t)time;
stream_id = (int32_t)stream;
// video chunk-id
prefer_cid = RTMP_CID_Video;
}
SrsCommonMessage::SrsCommonMessage()
@ -299,126 +323,12 @@ srs_error_t SrsCommonMessage::create(SrsMessageHeader *pheader, char *body, int
return err;
}
SrsSharedPtrMessage::SrsSharedPtrMessage() : timestamp(0), stream_id(0), message_type(0), prefer_cid(RTMP_CID_OverConnection)
void SrsCommonMessage::to_msg(SrsMediaPacket *msg)
{
payload_ = SrsSharedPtr<SrsMemoryBlock>(NULL);
++_srs_pps_objs_msgs->sugar;
}
SrsSharedPtrMessage::~SrsSharedPtrMessage()
{
// payload_ automatically cleaned up by SrsSharedPtr
}
srs_error_t SrsSharedPtrMessage::create(SrsCommonMessage *msg)
{
srs_error_t err = srs_success;
// Share the memory block from the common message
payload_ = msg->payload_;
this->timestamp = msg->header.timestamp;
this->stream_id = msg->header.stream_id;
this->message_type = msg->header.message_type;
this->prefer_cid = msg->header.prefer_cid;
return err;
}
srs_error_t SrsSharedPtrMessage::create(SrsMessageHeader *pheader, char *payload, int size)
{
srs_error_t err = srs_success;
if (size < 0) {
return srs_error_new(ERROR_RTMP_MESSAGE_CREATE, "create message size=%d", size);
}
// Create new memory block and attach the payload
payload_ = SrsSharedPtr<SrsMemoryBlock>(new SrsMemoryBlock());
payload_->attach(payload, size);
// Set header information
if (pheader) {
this->timestamp = pheader->timestamp;
this->stream_id = pheader->stream_id;
this->message_type = pheader->message_type;
this->prefer_cid = pheader->prefer_cid;
}
return err;
}
void SrsSharedPtrMessage::wrap(char *payload, int size)
{
// Create new memory block and wrap the payload
payload_ = SrsSharedPtr<SrsMemoryBlock>(new SrsMemoryBlock());
payload_->attach(payload, size);
}
bool SrsSharedPtrMessage::check(int stream_id)
{
// Ignore error when message has no payload.
if (!payload_.get()) {
return true;
}
// we assume that the stream_id in a group must be the same.
if (this->stream_id == stream_id) {
return true;
}
this->stream_id = stream_id;
return false;
}
bool SrsSharedPtrMessage::is_av()
{
return message_type == RTMP_MSG_AudioMessage || message_type == RTMP_MSG_VideoMessage;
}
bool SrsSharedPtrMessage::is_audio()
{
return message_type == RTMP_MSG_AudioMessage;
}
bool SrsSharedPtrMessage::is_video()
{
return message_type == RTMP_MSG_VideoMessage;
}
int SrsSharedPtrMessage::chunk_header(char *cache, int nb_cache, bool c0)
{
int payload_length = payload_.get() ? payload_->size() : 0;
if (c0) {
return srs_chunk_header_c0(prefer_cid, (uint32_t)timestamp,
payload_length, message_type, stream_id, cache, nb_cache);
} else {
return srs_chunk_header_c3(prefer_cid, (uint32_t)timestamp,
cache, nb_cache);
}
}
SrsSharedPtrMessage *SrsSharedPtrMessage::copy()
{
SrsSharedPtrMessage *copy = copy2();
copy->timestamp = timestamp;
copy->stream_id = stream_id;
copy->message_type = message_type;
copy->prefer_cid = prefer_cid;
return copy;
}
SrsSharedPtrMessage *SrsSharedPtrMessage::copy2()
{
SrsSharedPtrMessage *copy = new SrsSharedPtrMessage();
// Share the memory block
copy->payload_ = payload_;
return copy;
msg->payload_ = payload_;
msg->timestamp = header.timestamp;
msg->stream_id = header.stream_id;
msg->message_type = (SrsFrameType)header.message_type;
}
SrsFlvTransmuxer::SrsFlvTransmuxer()
@ -566,7 +476,7 @@ int SrsFlvTransmuxer::size_tag(int data_size)
return SRS_FLV_TAG_HEADER_SIZE + data_size + SRS_FLV_PREVIOUS_TAG_SIZE;
}
srs_error_t SrsFlvTransmuxer::write_tags(SrsSharedPtrMessage **msgs, int count)
srs_error_t SrsFlvTransmuxer::write_tags(SrsMediaPacket **msgs, int count)
{
srs_error_t err = srs_success;
@ -604,7 +514,7 @@ srs_error_t SrsFlvTransmuxer::write_tags(SrsSharedPtrMessage **msgs, int count)
iovec *iovs = iovss;
int nn_real_iovss = 0;
for (int i = 0; i < count; i++) {
SrsSharedPtrMessage *msg = msgs[i];
SrsMediaPacket *msg = msgs[i];
// Cache FLV packet header.
if (msg->is_audio()) {

100
trunk/src/kernel/srs_kernel_flv.hpp
View File

@ -14,6 +14,8 @@
#include <srs_core_autofree.hpp>
#include <srs_kernel_buffer.hpp>
#include <srs_kernel_codec.hpp>
#include <srs_kernel_packet.hpp>
// For srs-librtmp, @see https://github.com/ossrs/srs/issues/213
#ifndef _WIN32
@ -24,8 +26,8 @@ class SrsBuffer;
class ISrsWriter;
class ISrsReader;
class SrsFileReader;
class SrsPacket;
class SrsSample;
class SrsRtmpCommand;
class SrsNaluSample;
#define SRS_FLV_TAG_HEADER_SIZE 11
#define SRS_FLV_PREVIOUS_TAG_SIZE 4
@ -156,12 +158,6 @@ public:
// @remark, we use 64bits for large time for jitter detect and hls.
int64_t timestamp;
public:
// Get the prefered cid(chunk stream id) which sendout over.
// set at decoding, and canbe used for directly send message,
// For example, dispatch to all connections.
int prefer_cid;
public:
SrsMessageHeader();
virtual ~SrsMessageHeader();
@ -222,80 +218,9 @@ public:
// @remark user should never free the body.
// @param pheader, the header to copy to the message. NULL to ignore.
virtual srs_error_t create(SrsMessageHeader *pheader, char *body, int size);
};
// The shared ptr message.
// For audio/video/data message that need less memory copy.
// and only for output.
//
// Create first object by constructor and create(),
// use copy if need reference count message.
class SrsSharedPtrMessage
{
// 4.1. Message Header
public:
// Four-byte field that contains a timestamp of the message.
// The 4 bytes are packed in the big-endian order.
// @remark, used as calc timestamp when decode and encode time.
// @remark, we use 64bits for large time for jitter detect and hls.
int64_t timestamp;
// 4bytes.
// Four-byte field that identifies the stream of the message. These
// bytes are set in big-endian format.
int32_t stream_id;
// Message type for determining audio/video/data
int8_t message_type;
// Preferred chunk ID for RTMP chunking
int prefer_cid;
public:
// 4.2. Message Payload
SrsSharedPtr<SrsMemoryBlock> payload_;
public:
SrsSharedPtrMessage();
virtual ~SrsSharedPtrMessage();
public:
// Backward compatibility accessors
char *payload() { return payload_.get() ? payload_->payload() : NULL; }
int size() { return payload_.get() ? payload_->size() : 0; }
public:
// Create shared ptr message,
// copy header, manage the payload of msg,
// set the payload to NULL to prevent double free.
// @remark payload of msg set to NULL if success.
// @remark User should free the msg.
virtual srs_error_t create(SrsCommonMessage *msg);
// Create shared ptr message,
// from the header and payload.
// @remark user should never free the payload.
// @param pheader, the header to copy to the message. NULL to ignore.
virtual srs_error_t create(SrsMessageHeader *pheader, char *payload, int size);
// Create shared ptr message from RAW payload.
// @remark Note that the header is set to zero.
virtual void wrap(char *payload, int size);
// check prefer cid and stream id.
// @return whether stream id already set.
virtual bool check(int stream_id);
public:
virtual bool is_av();
virtual bool is_audio();
virtual bool is_video();
public:
// generate the chunk header to cache.
// @return the size of header.
virtual int chunk_header(char *cache, int nb_cache, bool c0);
public:
// copy current shared ptr message, use ref-count.
// @remark, assert object is created.
virtual SrsSharedPtrMessage *copy();
// Only copy the buffer, without header fields.
virtual SrsSharedPtrMessage *copy2();
// Convert to shared ptr message.
void to_msg(SrsMediaPacket *msg);
};
// Transmux RTMP packets to FLV stream.
@ -363,7 +288,7 @@ private:
public:
// Write the tags in a time.
virtual srs_error_t write_tags(SrsSharedPtrMessage **msgs, int count);
virtual srs_error_t write_tags(SrsMediaPacket **msgs, int count);
private:
virtual void cache_metadata(char type, char *data, int size, char *cache);
@ -439,6 +364,17 @@ public:
virtual srs_error_t seek2(int64_t offset);
};
// Get the prefer cid for message type.
extern int srs_rtmp_prefer_cid(SrsFrameType message_type);
// Generate the RTMP chunk header for shared ptr message.
// @param msg, the shared ptr message to generate header for.
// @param cache, the cache to write header.
// @param nb_cache, the size of cache.
// @param c0, whether to use c0 format (true) or c3 format (false).
// @return the size of header. 0 if cache not enough.
extern int srs_rtmp_write_chunk_header(SrsMediaPacket *msg, char *cache, int nb_cache, bool c0);
// Generate the c0 chunk header for msg.
// @param cache, the cache to write header.
// @param nb_cache, the size of cache.

2
trunk/src/kernel/srs_kernel_kbps.cpp
View File

@ -154,6 +154,8 @@ SrsPps *_srs_pps_rrtcps = NULL;
// NACK and loss statistics (only _srs_pps_aloss2 was originally in srs_app_server.cpp)
SrsPps *_srs_pps_aloss2 = NULL;
SrsPps *_srs_pps_objs_msgs = NULL;
#if defined(SRS_DEBUG) && defined(SRS_DEBUG_STATS)
// Debug thread statistics
SrsPps *_srs_pps_thread_run = NULL;

2
trunk/src/kernel/srs_kernel_kbps.hpp
View File

@ -167,6 +167,8 @@ extern SrsPps *_srs_pps_objs_rbuf;
extern SrsPps *_srs_pps_objs_msgs;
extern SrsPps *_srs_pps_objs_rothers;
extern SrsPps *_srs_pps_objs_msgs;
#if defined(SRS_DEBUG) && defined(SRS_DEBUG_STATS)
// Debug thread statistics
extern SrsPps *_srs_pps_thread_run;

1
trunk/src/kernel/srs_kernel_mp4.cpp
View File

@ -12,6 +12,7 @@
#include <srs_kernel_error.hpp>
#include <srs_kernel_io.hpp>
#include <srs_kernel_log.hpp>
#include <srs_kernel_packet.hpp>
#include <srs_kernel_stream.hpp>
#include <srs_kernel_utility.hpp>

2451
trunk/src/kernel/srs_kernel_packet.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

260
trunk/src/kernel/srs_kernel_packet.hpp Normal file
View File

@ -0,0 +1,260 @@
//
// Copyright (c) 2013-2025 The SRS Authors
//
// SPDX-License-Identifier: MIT
//
#ifndef SRS_KERNEL_PACKET_HPP
#define SRS_KERNEL_PACKET_HPP
#include <srs_core.hpp>
#include <srs_kernel_codec.hpp>
/**
* A sample is the NAL unit of a parsed packet.
* It's a NALU for H.264, H.265.
* It's the whole AAC raw data for AAC.
* @remark Neither SPS/PPS or ASC is sample unit, it's codec sequence header.
*/
class SrsNaluSample
{
public:
// The size of unit.
int size;
// The ptr of unit, user must free it.
char *bytes;
public:
SrsNaluSample();
SrsNaluSample(char *b, int s);
~SrsNaluSample();
public:
// Copy sample, share the bytes pointer.
SrsNaluSample *copy();
};
// A media packet containing raw, undecoded media data.
// This represents a single media frame or packet with timing information
// and payload data, but without codec-specific parsing or decoding.
class SrsMediaPacket
{
public:
// Timestamp of the media packet. The timebase is defined by context.
int64_t timestamp;
// Type of the media packet (audio, video, or script).
SrsFrameType message_type;
public:
// Stream identifier for the packet. It's optional, so only used for some
// protocols, for example, RTMP.
int32_t stream_id;
public:
// Raw payload data of the media packet.
SrsSharedPtr<SrsMemoryBlock> payload_;
public:
SrsMediaPacket();
virtual ~SrsMediaPacket();
public:
// Backward compatibility accessors
char *payload() { return payload_.get() ? payload_->payload() : NULL; }
int size() { return payload_.get() ? payload_->size() : 0; }
public:
// Create shared ptr message from RAW payload.
// @remark Note that the header is set to zero.
virtual void wrap(char *payload, int size);
// check prefer cid and stream id.
// @return whether stream id already set.
virtual bool check(int stream_id);
public:
virtual bool is_av();
virtual bool is_audio();
virtual bool is_video();
public:
// copy current shared ptr message, use ref-count.
// @remark, assert object is created.
virtual SrsMediaPacket *copy();
};
// A parsed packet, consists of a codec and a group of samples.
class SrsParsedPacket
{
public:
// The DTS/PTS in milliseconds, which is TBN=1000.
int64_t dts;
// PTS = DTS + CTS.
int32_t cts;
public:
// The codec info of frame.
SrsCodecConfig *codec;
// The actual parsed number of samples.
int nb_samples;
// The sampels cache.
SrsNaluSample samples[SrsMaxNbSamples];
public:
SrsParsedPacket();
virtual ~SrsParsedPacket();
public:
// Initialize the frame, to parse sampels.
virtual srs_error_t initialize(SrsCodecConfig *c);
// Add a sample to frame.
virtual srs_error_t add_sample(char *bytes, int size);
};
// A parsed audio packet, besides a frame, contains the audio frame info, such as frame type.
class SrsParsedAudioPacket : public SrsParsedPacket
{
public:
SrsAudioAacFrameTrait aac_packet_type;
public:
SrsParsedAudioPacket();
virtual ~SrsParsedAudioPacket();
public:
virtual SrsAudioCodecConfig *acodec();
};
// A parsed video packet, besides a frame, contains the video frame info, such as frame type.
class SrsParsedVideoPacket : public SrsParsedPacket
{
public:
// video specified
SrsVideoAvcFrameType frame_type;
SrsVideoAvcFrameTrait avc_packet_type;
// whether sample_units contains IDR frame.
bool has_idr;
// Whether exists AUD NALU.
bool has_aud;
// Whether exists SPS/PPS NALU.
bool has_sps_pps;
// The first nalu type.
SrsAvcNaluType first_nalu_type;
public:
SrsParsedVideoPacket();
virtual ~SrsParsedVideoPacket();
public:
// Initialize the frame, to parse sampels.
virtual srs_error_t initialize(SrsCodecConfig *c);
// Add the sample without ANNEXB or IBMF header, or RAW AAC or MP3 data.
virtual srs_error_t add_sample(char *bytes, int size);
public:
virtual SrsVideoCodecConfig *vcodec();
public:
static srs_error_t parse_avc_nalu_type(const SrsNaluSample *sample, SrsAvcNaluType &avc_nalu_type);
static srs_error_t parse_avc_bframe(const SrsNaluSample *sample, bool &is_b_frame);
static srs_error_t parse_hevc_nalu_type(const SrsNaluSample *sample, SrsHevcNaluType &hevc_nalu_type);
static srs_error_t parse_hevc_bframe(const SrsNaluSample *sample, SrsFormat *format, bool &is_b_frame);
};
/**
* A codec format, including one or many stream, each stream identified by a frame.
* For example, a typical RTMP stream format, consits of a video and audio frame.
* Maybe some RTMP stream only has a audio stream, for instance, redio application.
*/
class SrsFormat
{
public:
SrsParsedAudioPacket *audio;
SrsAudioCodecConfig *acodec;
SrsParsedVideoPacket *video;
SrsVideoCodecConfig *vcodec;
public:
char *raw;
int nb_raw;
public:
// for sequence header, whether parse the h.264 sps.
// TODO: FIXME: Refine it.
bool avc_parse_sps;
// Whether try to parse in ANNEXB, then by IBMF.
bool try_annexb_first;
public:
SrsFormat();
virtual ~SrsFormat();
public:
// Initialize the format.
virtual srs_error_t initialize();
// When got a parsed audio packet.
// @param data The data in FLV format.
virtual srs_error_t on_audio(int64_t timestamp, char *data, int size);
// When got a parsed video packet.
// @param data The data in FLV format.
virtual srs_error_t on_video(int64_t timestamp, char *data, int size);
// When got a audio aac sequence header.
virtual srs_error_t on_aac_sequence_header(char *data, int size);
public:
virtual bool is_aac_sequence_header();
virtual bool is_mp3_sequence_header();
// TODO: is avc|hevc|av1 sequence header
virtual bool is_avc_sequence_header();
private:
// Demux the video packet in H.264 codec.
// The packet is muxed in FLV format, defined in flv specification.
// Demux the sps/pps from sequence header.
// Demux the samples from NALUs.
virtual srs_error_t video_avc_demux(SrsBuffer *stream, int64_t timestamp);
private:
virtual srs_error_t hevc_demux_hvcc(SrsBuffer *stream);
private:
virtual srs_error_t hevc_demux_vps_sps_pps(SrsHevcHvccNalu *nal);
virtual srs_error_t hevc_demux_vps_rbsp(char *rbsp, int nb_rbsp);
virtual srs_error_t hevc_demux_sps_rbsp(char *rbsp, int nb_rbsp);
virtual srs_error_t hevc_demux_pps_rbsp(char *rbsp, int nb_rbsp);
virtual srs_error_t hevc_demux_rbsp_ptl(SrsBitBuffer *bs, SrsHevcProfileTierLevel *ptl, int profile_present_flag, int max_sub_layers_minus1);
public:
virtual srs_error_t hevc_demux_vps(SrsBuffer *stream);
virtual srs_error_t hevc_demux_sps(SrsBuffer *stream);
virtual srs_error_t hevc_demux_pps(SrsBuffer *stream);
private:
// Parse the H.264 SPS/PPS.
virtual srs_error_t avc_demux_sps_pps(SrsBuffer *stream);
virtual srs_error_t avc_demux_sps();
virtual srs_error_t avc_demux_sps_rbsp(char *rbsp, int nb_rbsp);
private:
// Parse the H.264 or H.265 NALUs.
virtual srs_error_t video_nalu_demux(SrsBuffer *stream);
// Demux the avc NALU in "AnnexB" from ISO_IEC_14496-10-AVC-2003.pdf, page 211.
virtual srs_error_t avc_demux_annexb_format(SrsBuffer *stream);
virtual srs_error_t do_avc_demux_annexb_format(SrsBuffer *stream);
// Demux the avc NALU in "ISO Base Media File Format" from ISO_IEC_14496-15-AVC-format-2012.pdf, page 20
virtual srs_error_t avc_demux_ibmf_format(SrsBuffer *stream);
virtual srs_error_t do_avc_demux_ibmf_format(SrsBuffer *stream);
private:
// Demux the audio packet in AAC codec.
// Demux the asc from sequence header.
// Demux the sampels from RAW data.
virtual srs_error_t audio_aac_demux(SrsBuffer *stream, int64_t timestamp);
virtual srs_error_t audio_mp3_demux(SrsBuffer *stream, int64_t timestamp, bool fresh);
public:
// Directly demux the sequence header, without RTMP packet header.
virtual srs_error_t audio_aac_sequence_header_demux(char *data, int size);
};
#endif

82
trunk/src/kernel/srs_kernel_rtc_rtp.cpp
View File

@ -1006,7 +1006,7 @@ SrsRtpRawPayload::SrsRtpRawPayload()
{
payload = NULL;
nn_payload = 0;
sample_ = new SrsSample();
sample_ = new SrsNaluSample();
++_srs_pps_objs_rraw->sugar;
}
@ -1077,19 +1077,19 @@ SrsRtpRawNALUs::~SrsRtpRawNALUs()
{
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
srs_freep(p);
}
}
void SrsRtpRawNALUs::push_back(SrsSample *sample)
void SrsRtpRawNALUs::push_back(SrsNaluSample *sample)
{
if (sample->size <= 0) {
return;
}
if (!nalus.empty()) {
SrsSample *p = new SrsSample();
SrsNaluSample *p = new SrsNaluSample();
p->bytes = (char *)"\0\0\1";
p->size = 3;
nn_bytes += 3;
@ -1107,7 +1107,7 @@ uint8_t SrsRtpRawNALUs::skip_bytes(int count)
return uint8_t(nalus[0]->bytes[0]);
}
srs_error_t SrsRtpRawNALUs::read_samples(vector<SrsSample *> &samples, int packet_size)
srs_error_t SrsRtpRawNALUs::read_samples(vector<SrsNaluSample *> &samples, int packet_size)
{
if (cursor + packet_size < 0 || cursor + packet_size > nn_bytes) {
return srs_error_new(ERROR_RTC_RTP_MUXER, "cursor=%d, max=%d, size=%d", cursor, nn_bytes, packet_size);
@ -1119,7 +1119,7 @@ srs_error_t SrsRtpRawNALUs::read_samples(vector<SrsSample *> &samples, int packe
int nn_nalus = (int)nalus.size();
for (int i = 0; left > 0 && i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
// Ignore previous consumed samples.
if (pos && pos - p->size >= 0) {
@ -1131,7 +1131,7 @@ srs_error_t SrsRtpRawNALUs::read_samples(vector<SrsSample *> &samples, int packe
int nn = srs_min(left, p->size - pos);
srs_assert(nn > 0);
SrsSample *sample = new SrsSample();
SrsNaluSample *sample = new SrsNaluSample();
samples.push_back(sample);
sample->bytes = p->bytes + pos;
@ -1150,7 +1150,7 @@ uint64_t SrsRtpRawNALUs::nb_bytes()
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
size += p->size;
}
@ -1161,7 +1161,7 @@ srs_error_t SrsRtpRawNALUs::encode(SrsBuffer *buf)
{
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
if (!buf->require(p->size)) {
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", p->size);
@ -1179,7 +1179,7 @@ srs_error_t SrsRtpRawNALUs::decode(SrsBuffer *buf)
return srs_success;
}
SrsSample *sample = new SrsSample();
SrsNaluSample *sample = new SrsNaluSample();
sample->bytes = buf->head();
sample->size = buf->left();
buf->skip(sample->size);
@ -1198,7 +1198,7 @@ ISrsRtpPayloader *SrsRtpRawNALUs::copy()
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
cp->nalus.push_back(p->copy());
}
@ -1216,16 +1216,16 @@ SrsRtpSTAPPayload::~SrsRtpSTAPPayload()
{
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
srs_freep(p);
}
}
SrsSample *SrsRtpSTAPPayload::get_sps()
SrsNaluSample *SrsRtpSTAPPayload::get_sps()
{
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
if (!p || !p->size) {
continue;
}
@ -1239,11 +1239,11 @@ SrsSample *SrsRtpSTAPPayload::get_sps()
return NULL;
}
SrsSample *SrsRtpSTAPPayload::get_pps()
SrsNaluSample *SrsRtpSTAPPayload::get_pps()
{
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
if (!p || !p->size) {
continue;
}
@ -1263,7 +1263,7 @@ uint64_t SrsRtpSTAPPayload::nb_bytes()
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
size += 2 + p->size;
}
@ -1285,7 +1285,7 @@ srs_error_t SrsRtpSTAPPayload::encode(SrsBuffer *buf)
// NALUs.
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
if (!buf->require(2 + p->size)) {
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 2 + p->size);
@ -1328,7 +1328,7 @@ srs_error_t SrsRtpSTAPPayload::decode(SrsBuffer *buf)
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", size);
}
SrsSample *sample = new SrsSample();
SrsNaluSample *sample = new SrsNaluSample();
sample->bytes = buf->head();
sample->size = size;
buf->skip(size);
@ -1347,7 +1347,7 @@ ISrsRtpPayloader *SrsRtpSTAPPayload::copy()
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
cp->nalus.push_back(p->copy());
}
@ -1366,7 +1366,7 @@ SrsRtpFUAPayload::~SrsRtpFUAPayload()
{
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
srs_freep(p);
}
}
@ -1377,7 +1377,7 @@ uint64_t SrsRtpFUAPayload::nb_bytes()
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
size += p->size;
}
@ -1408,7 +1408,7 @@ srs_error_t SrsRtpFUAPayload::encode(SrsBuffer *buf)
// FU payload, @see https://tools.ietf.org/html/rfc6184#section-5.8
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
if (!buf->require(p->size)) {
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", p->size);
@ -1440,7 +1440,7 @@ srs_error_t SrsRtpFUAPayload::decode(SrsBuffer *buf)
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 1);
}
SrsSample *sample = new SrsSample();
SrsNaluSample *sample = new SrsNaluSample();
sample->bytes = buf->head();
sample->size = buf->left();
buf->skip(sample->size);
@ -1461,7 +1461,7 @@ ISrsRtpPayloader *SrsRtpFUAPayload::copy()
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
cp->nalus.push_back(p->copy());
}
@ -1571,16 +1571,16 @@ SrsRtpSTAPPayloadHevc::~SrsRtpSTAPPayloadHevc()
{
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
srs_freep(p);
}
}
SrsSample *SrsRtpSTAPPayloadHevc::get_vps()
SrsNaluSample *SrsRtpSTAPPayloadHevc::get_vps()
{
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
if (!p || !p->size) {
continue;
}
@ -1594,11 +1594,11 @@ SrsSample *SrsRtpSTAPPayloadHevc::get_vps()
return NULL;
}
SrsSample *SrsRtpSTAPPayloadHevc::get_sps()
SrsNaluSample *SrsRtpSTAPPayloadHevc::get_sps()
{
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
if (!p || !p->size) {
continue;
}
@ -1612,11 +1612,11 @@ SrsSample *SrsRtpSTAPPayloadHevc::get_sps()
return NULL;
}
SrsSample *SrsRtpSTAPPayloadHevc::get_pps()
SrsNaluSample *SrsRtpSTAPPayloadHevc::get_pps()
{
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
if (!p || !p->size) {
continue;
}
@ -1636,7 +1636,7 @@ uint64_t SrsRtpSTAPPayloadHevc::nb_bytes()
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
size += 2 + p->size;
}
@ -1657,7 +1657,7 @@ srs_error_t SrsRtpSTAPPayloadHevc::encode(SrsBuffer *buf)
// NALUs.
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
if (!buf->require(2 + p->size)) {
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 2 + p->size);
@ -1699,7 +1699,7 @@ srs_error_t SrsRtpSTAPPayloadHevc::decode(SrsBuffer *buf)
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", size);
}
SrsSample *sample = new SrsSample();
SrsNaluSample *sample = new SrsNaluSample();
sample->bytes = buf->head();
sample->size = size;
buf->skip(size);
@ -1716,7 +1716,7 @@ ISrsRtpPayloader *SrsRtpSTAPPayloadHevc::copy()
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
cp->nalus.push_back(p->copy());
}
@ -1735,7 +1735,7 @@ SrsRtpFUAPayloadHevc::~SrsRtpFUAPayloadHevc()
{
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
srs_freep(p);
}
}
@ -1746,7 +1746,7 @@ uint64_t SrsRtpFUAPayloadHevc::nb_bytes()
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
size += p->size;
}
@ -1770,7 +1770,7 @@ srs_error_t SrsRtpFUAPayloadHevc::encode(SrsBuffer *buf)
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
if (!buf->require(p->size)) {
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", p->size);
@ -1799,7 +1799,7 @@ srs_error_t SrsRtpFUAPayloadHevc::decode(SrsBuffer *buf)
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 1);
}
SrsSample *sample = new SrsSample();
SrsNaluSample *sample = new SrsNaluSample();
sample->bytes = buf->head();
sample->size = buf->left();
buf->skip(sample->size);
@ -1819,7 +1819,7 @@ ISrsRtpPayloader *SrsRtpFUAPayloadHevc::copy()
int nn_nalus = (int)nalus.size();
for (int i = 0; i < nn_nalus; i++) {
SrsSample *p = nalus[i];
SrsNaluSample *p = nalus[i];
cp->nalus.push_back(p->copy());
}

27
trunk/src/kernel/srs_kernel_rtc_rtp.hpp
View File

@ -12,6 +12,7 @@
#include <srs_core_autofree.hpp>
#include <srs_kernel_buffer.hpp>
#include <srs_kernel_codec.hpp>
#include <srs_kernel_packet.hpp>
#include <list>
#include <string>
@ -411,7 +412,7 @@ public:
public:
// Use the whole RAW RTP payload as a sample.
SrsSample *sample_;
SrsNaluSample *sample_;
public:
SrsRtpRawPayload();
@ -429,7 +430,7 @@ class SrsRtpRawNALUs : public ISrsRtpPayloader
{
private:
// We will manage the samples, but the sample itself point to the shared memory.
std::vector<SrsSample *> nalus;
std::vector<SrsNaluSample *> nalus;
int nn_bytes;
int cursor;
@ -438,12 +439,12 @@ public:
virtual ~SrsRtpRawNALUs();
public:
void push_back(SrsSample *sample);
void push_back(SrsNaluSample *sample);
public:
uint8_t skip_bytes(int count);
// We will manage the returned samples, if user want to manage it, please copy it.
srs_error_t read_samples(std::vector<SrsSample *> &samples, int packet_size);
srs_error_t read_samples(std::vector<SrsNaluSample *> &samples, int packet_size);
// interface ISrsRtpPayloader
public:
virtual uint64_t nb_bytes();
@ -460,15 +461,15 @@ public:
SrsAvcNaluType nri;
// The NALU samples, we will manage the samples.
// @remark We only refer to the memory, user must free its bytes.
std::vector<SrsSample *> nalus;
std::vector<SrsNaluSample *> nalus;
public:
SrsRtpSTAPPayload();
virtual ~SrsRtpSTAPPayload();
public:
SrsSample *get_sps();
SrsSample *get_pps();
SrsNaluSample *get_sps();
SrsNaluSample *get_pps();
// interface ISrsRtpPayloader
public:
virtual uint64_t nb_bytes();
@ -490,7 +491,7 @@ public:
SrsAvcNaluType nalu_type;
// The NALU samples, we manage the samples.
// @remark We only refer to the memory, user must free its bytes.
std::vector<SrsSample *> nalus;
std::vector<SrsNaluSample *> nalus;
public:
SrsRtpFUAPayload();
@ -534,16 +535,16 @@ class SrsRtpSTAPPayloadHevc : public ISrsRtpPayloader
public:
// The NALU samples, we will manage the samples.
// @remark We only refer to the memory, user must free its bytes.
std::vector<SrsSample *> nalus;
std::vector<SrsNaluSample *> nalus;
public:
SrsRtpSTAPPayloadHevc();
virtual ~SrsRtpSTAPPayloadHevc();
public:
SrsSample *get_vps();
SrsSample *get_sps();
SrsSample *get_pps();
SrsNaluSample *get_vps();
SrsNaluSample *get_sps();
SrsNaluSample *get_pps();
// interface ISrsRtpPayloader
public:
virtual uint64_t nb_bytes();
@ -563,7 +564,7 @@ public:
SrsHevcNaluType nalu_type;
// The NALU samples, we manage the samples.
// @remark We only refer to the memory, user must free its bytes.
std::vector<SrsSample *> nalus;
std::vector<SrsNaluSample *> nalus;
public:
SrsRtpFUAPayloadHevc();

20
trunk/src/kernel/srs_kernel_ts.cpp
View File

@ -2917,7 +2917,7 @@ SrsTsMessageCache::~SrsTsMessageCache()
srs_freep(video);
}
srs_error_t SrsTsMessageCache::cache_audio(SrsAudioFrame *frame, int64_t dts)
srs_error_t SrsTsMessageCache::cache_audio(SrsParsedAudioPacket *frame, int64_t dts)
{
srs_error_t err = srs_success;
@ -2951,7 +2951,7 @@ srs_error_t SrsTsMessageCache::cache_audio(SrsAudioFrame *frame, int64_t dts)
return err;
}
srs_error_t SrsTsMessageCache::cache_video(SrsVideoFrame *frame, int64_t dts)
srs_error_t SrsTsMessageCache::cache_video(SrsParsedVideoPacket *frame, int64_t dts)
{
srs_error_t err = srs_success;
@ -2979,21 +2979,21 @@ srs_error_t SrsTsMessageCache::cache_video(SrsVideoFrame *frame, int64_t dts)
return err;
}
srs_error_t SrsTsMessageCache::do_cache_mp3(SrsAudioFrame *frame)
srs_error_t SrsTsMessageCache::do_cache_mp3(SrsParsedAudioPacket *frame)
{
srs_error_t err = srs_success;
// for mp3, directly write to cache.
// TODO: FIXME: implements the ts jitter.
for (int i = 0; i < frame->nb_samples; i++) {
SrsSample *sample = &frame->samples[i];
SrsNaluSample *sample = &frame->samples[i];
audio->payload->append(sample->bytes, sample->size);
}
return err;
}
srs_error_t SrsTsMessageCache::do_cache_aac(SrsAudioFrame *frame)
srs_error_t SrsTsMessageCache::do_cache_aac(SrsParsedAudioPacket *frame)
{
srs_error_t err = srs_success;
@ -3001,7 +3001,7 @@ srs_error_t SrsTsMessageCache::do_cache_aac(SrsAudioFrame *frame)
srs_assert(codec);
for (int i = 0; i < frame->nb_samples; i++) {
SrsSample *sample = &frame->samples[i];
SrsNaluSample *sample = &frame->samples[i];
int32_t size = sample->size;
if (!sample->bytes || size <= 0 || size > 0x1fff) {
@ -3118,7 +3118,7 @@ void srs_avc_insert_aud(SrsSimpleStream *payload, bool aud_inserted)
}
}
srs_error_t SrsTsMessageCache::do_cache_avc(SrsVideoFrame *frame)
srs_error_t SrsTsMessageCache::do_cache_avc(SrsParsedVideoPacket *frame)
{
srs_error_t err = srs_success;
@ -3169,7 +3169,7 @@ srs_error_t SrsTsMessageCache::do_cache_avc(SrsVideoFrame *frame)
// all sample use cont nalu header, except the sps-pps before IDR frame.
for (int i = 0; i < frame->nb_samples; i++) {
SrsSample *sample = &frame->samples[i];
SrsNaluSample *sample = &frame->samples[i];
int32_t size = sample->size;
if (!sample->bytes || size <= 0) {
@ -3202,7 +3202,7 @@ srs_error_t SrsTsMessageCache::do_cache_avc(SrsVideoFrame *frame)
return err;
}
srs_error_t SrsTsMessageCache::do_cache_hevc(SrsVideoFrame *frame)
srs_error_t SrsTsMessageCache::do_cache_hevc(SrsParsedVideoPacket *frame)
{
srs_error_t err = srs_success;
@ -3216,7 +3216,7 @@ srs_error_t SrsTsMessageCache::do_cache_hevc(SrsVideoFrame *frame)
// all sample use cont nalu header, except the sps-pps before IDR frame.
for (int i = 0; i < frame->nb_samples; i++) {
SrsSample *sample = &frame->samples[i];
SrsNaluSample *sample = &frame->samples[i];
int32_t size = sample->size;
if (!sample->bytes || size <= 0) {

13
trunk/src/kernel/srs_kernel_ts.hpp
View File

@ -15,6 +15,7 @@
#include <srs_kernel_codec.hpp>
#include <srs_kernel_file.hpp>
#include <srs_kernel_packet.hpp>
class SrsBuffer;
class SrsTsMessageCache;
@ -1366,15 +1367,15 @@ public:
public:
// Write audio to cache
virtual srs_error_t cache_audio(SrsAudioFrame *frame, int64_t dts);
virtual srs_error_t cache_audio(SrsParsedAudioPacket *frame, int64_t dts);
// Write video to muxer.
virtual srs_error_t cache_video(SrsVideoFrame *frame, int64_t dts);
virtual srs_error_t cache_video(SrsParsedVideoPacket *frame, int64_t dts);
private:
virtual srs_error_t do_cache_mp3(SrsAudioFrame *frame);
virtual srs_error_t do_cache_aac(SrsAudioFrame *frame);
virtual srs_error_t do_cache_avc(SrsVideoFrame *frame);
virtual srs_error_t do_cache_hevc(SrsVideoFrame *frame);
virtual srs_error_t do_cache_mp3(SrsParsedAudioPacket *frame);
virtual srs_error_t do_cache_aac(SrsParsedAudioPacket *frame);
virtual srs_error_t do_cache_avc(SrsParsedVideoPacket *frame);
virtual srs_error_t do_cache_hevc(SrsParsedVideoPacket *frame);
};
// Transmux the RTMP stream to HTTP-TS stream.

8
trunk/src/protocol/srs_protocol_format.cpp
View File

@ -27,9 +27,9 @@ srs_error_t SrsRtmpFormat::on_metadata(SrsOnMetaDataPacket *meta)
return srs_success;
}
srs_error_t SrsRtmpFormat::on_audio(SrsSharedPtrMessage *shared_audio)
srs_error_t SrsRtmpFormat::on_audio(SrsMediaPacket *shared_audio)
{
SrsSharedPtrMessage *msg = shared_audio;
SrsMediaPacket *msg = shared_audio;
char *data = msg->payload();
int size = msg->size();
@ -41,9 +41,9 @@ srs_error_t SrsRtmpFormat::on_audio(int64_t timestamp, char *data, int size)
return SrsFormat::on_audio(timestamp, data, size);
}
srs_error_t SrsRtmpFormat::on_video(SrsSharedPtrMessage *shared_video)
srs_error_t SrsRtmpFormat::on_video(SrsMediaPacket *shared_video)
{
SrsSharedPtrMessage *msg = shared_video;
SrsMediaPacket *msg = shared_video;
char *data = msg->payload();
int size = msg->size();

7
trunk/src/protocol/srs_protocol_format.hpp
View File

@ -10,9 +10,10 @@
#include <srs_core.hpp>
#include <srs_kernel_codec.hpp>
#include <srs_kernel_packet.hpp>
class SrsOnMetaDataPacket;
class SrsSharedPtrMessage;
class SrsMediaPacket;
/**
* Create special structure from RTMP stream, for example, the metadata.
@ -27,10 +28,10 @@ public:
// Initialize the format from metadata, optional.
virtual srs_error_t on_metadata(SrsOnMetaDataPacket *meta);
// When got a parsed audio packet.
virtual srs_error_t on_audio(SrsSharedPtrMessage *shared_audio);
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio);
virtual srs_error_t on_audio(int64_t timestamp, char *data, int size);
// When got a parsed video packet.
virtual srs_error_t on_video(SrsSharedPtrMessage *shared_video);
virtual srs_error_t on_video(SrsMediaPacket *shared_video);
virtual srs_error_t on_video(int64_t timestamp, char *data, int size);
};

1
trunk/src/protocol/srs_protocol_raw_avc.cpp
View File

@ -14,6 +14,7 @@ using namespace std;
#include <srs_kernel_codec.hpp>
#include <srs_kernel_error.hpp>
#include <srs_kernel_log.hpp>
#include <srs_kernel_packet.hpp>
#include <srs_kernel_utility.hpp>
bool srs_aac_startswith_adts(SrsBuffer *stream)

6
trunk/src/protocol/srs_protocol_rtmp_conn.cpp
View File

@ -206,17 +206,17 @@ srs_error_t SrsBasicRtmpClient::recv_message(SrsCommonMessage **pmsg)
return client->recv_message(pmsg);
}
srs_error_t SrsBasicRtmpClient::decode_message(SrsCommonMessage *msg, SrsPacket **ppacket)
srs_error_t SrsBasicRtmpClient::decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket)
{
return client->decode_message(msg, ppacket);
}
srs_error_t SrsBasicRtmpClient::send_and_free_messages(SrsSharedPtrMessage **msgs, int nb_msgs)
srs_error_t SrsBasicRtmpClient::send_and_free_messages(SrsMediaPacket **msgs, int nb_msgs)
{
return client->send_and_free_messages(msgs, nb_msgs, stream_id);
}
srs_error_t SrsBasicRtmpClient::send_and_free_message(SrsSharedPtrMessage *msg)
srs_error_t SrsBasicRtmpClient::send_and_free_message(SrsMediaPacket *msg)
{
return client->send_and_free_message(msg, stream_id);
}

10
trunk/src/protocol/srs_protocol_rtmp_conn.hpp
View File

@ -15,8 +15,8 @@ class ISrsRequest;
class SrsTcpClient;
class SrsRtmpClient;
class SrsCommonMessage;
class SrsSharedPtrMessage;
class SrsPacket;
class SrsMediaPacket;
class SrsRtmpCommand;
class SrsNetworkKbps;
class SrsWallClock;
class SrsAmf0Object;
@ -75,9 +75,9 @@ public:
public:
virtual srs_error_t recv_message(SrsCommonMessage **pmsg);
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsPacket **ppacket);
virtual srs_error_t send_and_free_messages(SrsSharedPtrMessage **msgs, int nb_msgs);
virtual srs_error_t send_and_free_message(SrsSharedPtrMessage *msg);
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket);
virtual srs_error_t send_and_free_messages(SrsMediaPacket **msgs, int nb_msgs);
virtual srs_error_t send_and_free_message(SrsMediaPacket *msg);
public:
virtual void set_recv_timeout(srs_utime_t timeout);

4
trunk/src/protocol/srs_protocol_rtmp_msg_array.cpp
View File

@ -12,7 +12,7 @@ SrsMessageArray::SrsMessageArray(int max_msgs)
{
srs_assert(max_msgs > 0);
msgs = new SrsSharedPtrMessage *[max_msgs];
msgs = new SrsMediaPacket *[max_msgs];
max = max_msgs;
zero(max_msgs);
@ -30,7 +30,7 @@ void SrsMessageArray::free(int count)
{
// initialize
for (int i = 0; i < count; i++) {
SrsSharedPtrMessage *msg = msgs[i];
SrsMediaPacket *msg = msgs[i];
srs_freep(msg);
msgs[i] = NULL;

4
trunk/src/protocol/srs_protocol_rtmp_msg_array.hpp
View File

@ -9,7 +9,7 @@
#include <srs_core.hpp>
class SrsSharedPtrMessage;
class SrsMediaPacket;
// The class to auto free the shared ptr message array.
// When need to get some messages, for instance, from Consumer queue,
@ -24,7 +24,7 @@ public:
// When user already send all msgs, please set to NULL,
// for instance, msg= msgs.msgs[i], msgs.msgs[i]=NULL, send(msg),
// where send(msg) will always send and free it.
SrsSharedPtrMessage **msgs;
SrsMediaPacket **msgs;
int max;
public:

225
trunk/src/protocol/srs_protocol_rtmp_stack.cpp
View File

@ -79,15 +79,15 @@ using namespace std;
*****************************************************************************
****************************************************************************/
SrsPacket::SrsPacket()
SrsRtmpCommand::SrsRtmpCommand()
{
}
SrsPacket::~SrsPacket()
SrsRtmpCommand::~SrsRtmpCommand()
{
}
srs_error_t SrsPacket::to_msg(SrsCommonMessage *msg, int stream_id)
srs_error_t SrsRtmpCommand::to_msg(SrsCommonMessage *msg, int stream_id)
{
srs_error_t err = srs_success;
@ -108,7 +108,6 @@ srs_error_t SrsPacket::to_msg(SrsCommonMessage *msg, int stream_id)
header.payload_length = size;
header.message_type = get_message_type();
header.stream_id = stream_id;
header.prefer_cid = get_prefer_cid();
if ((err = msg->create(&header, payload, size)) != srs_success) {
return srs_error_wrap(err, "create %dB message", size);
@ -117,7 +116,7 @@ srs_error_t SrsPacket::to_msg(SrsCommonMessage *msg, int stream_id)
return err;
}
srs_error_t SrsPacket::encode(int &psize, char *&ppayload)
srs_error_t SrsRtmpCommand::encode(int &psize, char *&ppayload)
{
srs_error_t err = srs_success;
@ -140,27 +139,22 @@ srs_error_t SrsPacket::encode(int &psize, char *&ppayload)
return err;
}
srs_error_t SrsPacket::decode(SrsBuffer *stream)
srs_error_t SrsRtmpCommand::decode(SrsBuffer *stream)
{
return srs_error_new(ERROR_SYSTEM_PACKET_INVALID, "decode");
}
int SrsPacket::get_prefer_cid()
int SrsRtmpCommand::get_message_type()
{
return 0;
}
int SrsPacket::get_message_type()
int SrsRtmpCommand::get_size()
{
return 0;
}
int SrsPacket::get_size()
{
return 0;
}
srs_error_t SrsPacket::encode_packet(SrsBuffer *stream)
srs_error_t SrsRtmpCommand::encode_packet(SrsBuffer *stream)
{
return srs_error_new(ERROR_SYSTEM_PACKET_INVALID, "encode");
}
@ -196,10 +190,6 @@ SrsProtocol::SrsProtocol(ISrsProtocolReadWriter *io)
}
for (int cid = 0; cid < SRS_PERF_CHUNK_STREAM_CACHE; cid++) {
SrsChunkStream *cs = new SrsChunkStream(cid);
// set the prefer cid of chunk,
// which will copy to the message received.
cs->header.prefer_cid = cid;
cs_cache[cid] = cs;
}
@ -220,9 +210,9 @@ SrsProtocol::~SrsProtocol()
}
if (true) {
std::vector<SrsPacket *>::iterator it;
std::vector<SrsRtmpCommand *>::iterator it;
for (it = manual_response_queue.begin(); it != manual_response_queue.end(); ++it) {
SrsPacket *pkt = *it;
SrsRtmpCommand *pkt = *it;
srs_freep(pkt);
}
manual_response_queue.clear();
@ -259,9 +249,9 @@ srs_error_t SrsProtocol::manual_response_flush()
return err;
}
std::vector<SrsPacket *>::iterator it;
std::vector<SrsRtmpCommand *>::iterator it;
for (it = manual_response_queue.begin(); it != manual_response_queue.end();) {
SrsPacket *pkt = *it;
SrsRtmpCommand *pkt = *it;
// erase this packet, the send api always free it.
it = manual_response_queue.erase(it);
@ -361,7 +351,7 @@ srs_error_t SrsProtocol::recv_message(SrsCommonMessage **pmsg)
return err;
}
srs_error_t SrsProtocol::decode_message(SrsCommonMessage *msg, SrsPacket **ppacket)
srs_error_t SrsProtocol::decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket)
{
*ppacket = NULL;
@ -374,7 +364,7 @@ srs_error_t SrsProtocol::decode_message(SrsCommonMessage *msg, SrsPacket **ppack
SrsBuffer stream(msg->payload(), msg->size());
// decode the packet.
SrsPacket *packet = NULL;
SrsRtmpCommand *packet = NULL;
if ((err = do_decode_message(msg->header, &stream, &packet)) != srs_success) {
srs_freep(packet);
return srs_error_wrap(err, "decode message");
@ -386,7 +376,7 @@ srs_error_t SrsProtocol::decode_message(SrsCommonMessage *msg, SrsPacket **ppack
return err;
}
srs_error_t SrsProtocol::do_send_messages(SrsSharedPtrMessage **msgs, int nb_msgs)
srs_error_t SrsProtocol::do_send_messages(SrsMediaPacket **msgs, int nb_msgs)
{
srs_error_t err = srs_success;
@ -400,7 +390,7 @@ srs_error_t SrsProtocol::do_send_messages(SrsSharedPtrMessage **msgs, int nb_msg
// try to send use the c0c3 header cache,
// if cache is consumed, try another loop.
for (int i = 0; i < nb_msgs; i++) {
SrsSharedPtrMessage *msg = msgs[i];
SrsMediaPacket *msg = msgs[i];
if (!msg) {
continue;
@ -420,7 +410,7 @@ srs_error_t SrsProtocol::do_send_messages(SrsSharedPtrMessage **msgs, int nb_msg
while (p < pend) {
// always has header
int nb_cache = SRS_CONSTS_C0C3_HEADERS_MAX - c0c3_cache_index;
int nbh = msg->chunk_header(c0c3_cache, nb_cache, p == msg->payload());
int nbh = srs_rtmp_write_chunk_header(msg, c0c3_cache, nb_cache, p == msg->payload());
srs_assert(nbh > 0);
// header iov
@ -498,7 +488,7 @@ srs_error_t SrsProtocol::do_send_messages(SrsSharedPtrMessage **msgs, int nb_msg
// try to send use the c0c3 header cache,
// if cache is consumed, try another loop.
for (int i = 0; i < nb_msgs; i++) {
SrsSharedPtrMessage *msg = msgs[i];
SrsMediaPacket *msg = msgs[i];
if (!msg) {
continue;
@ -522,7 +512,7 @@ srs_error_t SrsProtocol::do_send_messages(SrsSharedPtrMessage **msgs, int nb_msg
int nb_cache = SRS_CONSTS_C0C3_HEADERS_MAX;
// always has header
int nbh = msg->chunk_header(c0c3_cache, nb_cache, p == msg->payload);
int nbh = srs_rtmp_write_chunk_header(msg, c0c3_cache, nb_cache, p == msg->payload);
srs_assert(nbh > 0);
// header iov
@ -552,23 +542,20 @@ srs_error_t SrsProtocol::do_iovs_send(iovec *iovs, int size)
return srs_write_large_iovs(skt, iovs, size);
}
srs_error_t SrsProtocol::do_send_and_free_packet(SrsPacket *packet_raw, int stream_id)
srs_error_t SrsProtocol::do_send_and_free_packet(SrsRtmpCommand *packet_raw, int stream_id)
{
srs_error_t err = srs_success;
srs_assert(packet_raw);
SrsUniquePtr<SrsPacket> packet(packet_raw);
SrsUniquePtr<SrsRtmpCommand> packet(packet_raw);
SrsUniquePtr<SrsCommonMessage> msg(new SrsCommonMessage());
if ((err = packet->to_msg(msg.get(), stream_id)) != srs_success) {
return srs_error_wrap(err, "to message");
}
SrsSharedPtrMessage *shared_msg = new SrsSharedPtrMessage();
if ((err = shared_msg->create(msg.get())) != srs_success) {
srs_freep(shared_msg);
return srs_error_wrap(err, "create message");
}
SrsMediaPacket *shared_msg = new SrsMediaPacket();
msg->to_msg(shared_msg);
if ((err = send_and_free_message(shared_msg, stream_id)) != srs_success) {
return srs_error_wrap(err, "send packet");
@ -581,11 +568,11 @@ srs_error_t SrsProtocol::do_send_and_free_packet(SrsPacket *packet_raw, int stre
return err;
}
srs_error_t SrsProtocol::do_decode_message(SrsMessageHeader &header, SrsBuffer *stream, SrsPacket **ppacket)
srs_error_t SrsProtocol::do_decode_message(SrsMessageHeader &header, SrsBuffer *stream, SrsRtmpCommand **ppacket)
{
srs_error_t err = srs_success;
SrsPacket *packet = NULL;
SrsRtmpCommand *packet = NULL;
// decode specified packet type
if (header.is_amf0_command() || header.is_amf3_command() || header.is_amf0_data() || header.is_amf3_data()) {
@ -692,7 +679,7 @@ srs_error_t SrsProtocol::do_decode_message(SrsMessageHeader &header, SrsBuffer *
}
// default packet to drop message.
*ppacket = packet = new SrsPacket();
*ppacket = packet = new SrsRtmpCommand();
return err;
} else if (header.is_user_control_message()) {
*ppacket = packet = new SrsUserControlPacket();
@ -715,12 +702,12 @@ srs_error_t SrsProtocol::do_decode_message(SrsMessageHeader &header, SrsBuffer *
return err;
}
srs_error_t SrsProtocol::send_and_free_message(SrsSharedPtrMessage *msg, int stream_id)
srs_error_t SrsProtocol::send_and_free_message(SrsMediaPacket *msg, int stream_id)
{
return send_and_free_messages(&msg, 1, stream_id);
}
srs_error_t SrsProtocol::send_and_free_messages(SrsSharedPtrMessage **msgs, int nb_msgs, int stream_id)
srs_error_t SrsProtocol::send_and_free_messages(SrsMediaPacket **msgs, int nb_msgs, int stream_id)
{
// always not NULL msg.
srs_assert(msgs);
@ -728,7 +715,7 @@ srs_error_t SrsProtocol::send_and_free_messages(SrsSharedPtrMessage **msgs, int
// update the stream id in header.
for (int i = 0; i < nb_msgs; i++) {
SrsSharedPtrMessage *msg = msgs[i];
SrsMediaPacket *msg = msgs[i];
if (!msg) {
continue;
@ -746,7 +733,7 @@ srs_error_t SrsProtocol::send_and_free_messages(SrsSharedPtrMessage **msgs, int
srs_error_t err = do_send_messages(msgs, nb_msgs);
for (int i = 0; i < nb_msgs; i++) {
SrsSharedPtrMessage *msg = msgs[i];
SrsMediaPacket *msg = msgs[i];
srs_freep(msg);
}
@ -765,7 +752,7 @@ srs_error_t SrsProtocol::send_and_free_messages(SrsSharedPtrMessage **msgs, int
return err;
}
srs_error_t SrsProtocol::send_and_free_packet(SrsPacket *packet, int stream_id)
srs_error_t SrsProtocol::send_and_free_packet(SrsRtmpCommand *packet, int stream_id)
{
srs_error_t err = srs_success;
@ -806,9 +793,6 @@ srs_error_t SrsProtocol::recv_interlaced_message(SrsCommonMessage **pmsg)
// chunk stream cache miss, use map.
if (chunk_streams.find(cid) == chunk_streams.end()) {
chunk = chunk_streams[cid] = new SrsChunkStream(cid);
// set the prefer cid of chunk,
// which will copy to the message received.
chunk->header.prefer_cid = cid;
} else {
chunk = chunk_streams[cid];
}
@ -1250,7 +1234,7 @@ srs_error_t SrsProtocol::on_recv_message(SrsCommonMessage *msg)
return srs_error_wrap(err, "response ack");
}
SrsPacket *packet_raw = NULL;
SrsRtmpCommand *packet_raw = NULL;
switch (msg->header.message_type) {
case RTMP_MSG_SetChunkSize:
case RTMP_MSG_UserControlMessage:
@ -1268,7 +1252,7 @@ srs_error_t SrsProtocol::on_recv_message(SrsCommonMessage *msg)
// always free the packet.
srs_assert(packet_raw);
SrsUniquePtr<SrsPacket> packet(packet_raw);
SrsUniquePtr<SrsRtmpCommand> packet(packet_raw);
switch (msg->header.message_type) {
case RTMP_MSG_WindowAcknowledgementSize: {
@ -1324,7 +1308,7 @@ srs_error_t SrsProtocol::on_recv_message(SrsCommonMessage *msg)
return err;
}
srs_error_t SrsProtocol::on_send_packet(SrsMessageHeader *mh, SrsPacket *packet)
srs_error_t SrsProtocol::on_send_packet(SrsMessageHeader *mh, SrsRtmpCommand *packet)
{
srs_error_t err = srs_success;
@ -1831,22 +1815,22 @@ srs_error_t SrsRtmpClient::recv_message(SrsCommonMessage **pmsg)
return protocol->recv_message(pmsg);
}
srs_error_t SrsRtmpClient::decode_message(SrsCommonMessage *msg, SrsPacket **ppacket)
srs_error_t SrsRtmpClient::decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket)
{
return protocol->decode_message(msg, ppacket);
}
srs_error_t SrsRtmpClient::send_and_free_message(SrsSharedPtrMessage *msg, int stream_id)
srs_error_t SrsRtmpClient::send_and_free_message(SrsMediaPacket *msg, int stream_id)
{
return protocol->send_and_free_message(msg, stream_id);
}
srs_error_t SrsRtmpClient::send_and_free_messages(SrsSharedPtrMessage **msgs, int nb_msgs, int stream_id)
srs_error_t SrsRtmpClient::send_and_free_messages(SrsMediaPacket **msgs, int nb_msgs, int stream_id)
{
return protocol->send_and_free_messages(msgs, nb_msgs, stream_id);
}
srs_error_t SrsRtmpClient::send_and_free_packet(SrsPacket *packet, int stream_id)
srs_error_t SrsRtmpClient::send_and_free_packet(SrsRtmpCommand *packet, int stream_id)
{
return protocol->send_and_free_packet(packet, stream_id);
}
@ -2232,22 +2216,22 @@ srs_error_t SrsRtmpServer::recv_message(SrsCommonMessage **pmsg)
return protocol->recv_message(pmsg);
}
srs_error_t SrsRtmpServer::decode_message(SrsCommonMessage *msg, SrsPacket **ppacket)
srs_error_t SrsRtmpServer::decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket)
{
return protocol->decode_message(msg, ppacket);
}
srs_error_t SrsRtmpServer::send_and_free_message(SrsSharedPtrMessage *msg, int stream_id)
srs_error_t SrsRtmpServer::send_and_free_message(SrsMediaPacket *msg, int stream_id)
{
return protocol->send_and_free_message(msg, stream_id);
}
srs_error_t SrsRtmpServer::send_and_free_messages(SrsSharedPtrMessage **msgs, int nb_msgs, int stream_id)
srs_error_t SrsRtmpServer::send_and_free_messages(SrsMediaPacket **msgs, int nb_msgs, int stream_id)
{
return protocol->send_and_free_messages(msgs, nb_msgs, stream_id);
}
srs_error_t SrsRtmpServer::send_and_free_packet(SrsPacket *packet, int stream_id)
srs_error_t SrsRtmpServer::send_and_free_packet(SrsRtmpCommand *packet, int stream_id)
{
return protocol->send_and_free_packet(packet, stream_id);
}
@ -2496,11 +2480,11 @@ srs_error_t SrsRtmpServer::identify_client(int stream_id, SrsRtmpConnType &type,
continue;
}
SrsPacket *pkt_raw = NULL;
SrsRtmpCommand *pkt_raw = NULL;
if ((err = protocol->decode_message(msg.get(), &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "decode identify");
}
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
SrsUniquePtr<SrsRtmpCommand> pkt(pkt_raw);
if (dynamic_cast<SrsCreateStreamPacket *>(pkt.get())) {
return identify_create_stream_client(dynamic_cast<SrsCreateStreamPacket *>(pkt.get()), stream_id, 3, type, stream_name, duration);
@ -2598,7 +2582,7 @@ srs_error_t SrsRtmpServer::start_play(int stream_id)
// |RtmpSampleAccess(false, false)
if (true) {
SrsSampleAccessPacket *pkt = new SrsSampleAccessPacket();
SrsNaluSampleAccessPacket *pkt = new SrsNaluSampleAccessPacket();
// allow audio/video sample.
// @see: https://github.com/ossrs/srs/issues/49
@ -2887,11 +2871,11 @@ srs_error_t SrsRtmpServer::identify_create_stream_client(SrsCreateStreamPacket *
continue;
}
SrsPacket *pkt_raw = NULL;
SrsRtmpCommand *pkt_raw = NULL;
if ((err = protocol->decode_message(msg.get(), &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "decode identify");
}
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
SrsUniquePtr<SrsRtmpCommand> pkt(pkt_raw);
if (dynamic_cast<SrsPlayPacket *>(pkt.get())) {
return identify_play_client(dynamic_cast<SrsPlayPacket *>(pkt.get()), type, stream_name, duration);
@ -3033,11 +3017,6 @@ srs_error_t SrsConnectAppPacket::decode(SrsBuffer *stream)
return err;
}
int SrsConnectAppPacket::get_prefer_cid()
{
return RTMP_CID_OverConnection;
}
int SrsConnectAppPacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -3139,11 +3118,6 @@ srs_error_t SrsConnectAppResPacket::decode(SrsBuffer *stream)
return err;
}
int SrsConnectAppResPacket::get_prefer_cid()
{
return RTMP_CID_OverConnection;
}
int SrsConnectAppResPacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -3227,11 +3201,6 @@ srs_error_t SrsCallPacket::decode(SrsBuffer *stream)
return err;
}
int SrsCallPacket::get_prefer_cid()
{
return RTMP_CID_OverConnection;
}
int SrsCallPacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -3291,11 +3260,6 @@ SrsCallResPacket::~SrsCallResPacket()
srs_freep(response);
}
int SrsCallResPacket::get_prefer_cid()
{
return RTMP_CID_OverConnection;
}
int SrsCallResPacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -3381,11 +3345,6 @@ srs_error_t SrsCreateStreamPacket::decode(SrsBuffer *stream)
return err;
}
int SrsCreateStreamPacket::get_prefer_cid()
{
return RTMP_CID_OverConnection;
}
int SrsCreateStreamPacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -3454,11 +3413,6 @@ srs_error_t SrsCreateStreamResPacket::decode(SrsBuffer *stream)
return err;
}
int SrsCreateStreamResPacket::get_prefer_cid()
{
return RTMP_CID_OverConnection;
}
int SrsCreateStreamResPacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -3569,11 +3523,6 @@ srs_error_t SrsFMLEStartPacket::decode(SrsBuffer *stream)
return err;
}
int SrsFMLEStartPacket::get_prefer_cid()
{
return RTMP_CID_OverConnection;
}
int SrsFMLEStartPacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -3681,11 +3630,6 @@ srs_error_t SrsFMLEStartResPacket::decode(SrsBuffer *stream)
return err;
}
int SrsFMLEStartResPacket::get_prefer_cid()
{
return RTMP_CID_OverConnection;
}
int SrsFMLEStartResPacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -3768,11 +3712,6 @@ srs_error_t SrsPublishPacket::decode(SrsBuffer *stream)
return err;
}
int SrsPublishPacket::get_prefer_cid()
{
return RTMP_CID_OverStream;
}
int SrsPublishPacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -3927,11 +3866,6 @@ srs_error_t SrsPlayPacket::decode(SrsBuffer *stream)
return err;
}
int SrsPlayPacket::get_prefer_cid()
{
return RTMP_CID_OverStream;
}
int SrsPlayPacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -4017,11 +3951,6 @@ void SrsPlayResPacket::set_desc(SrsAmf0Object *v)
desc = v;
}
int SrsPlayResPacket::get_prefer_cid()
{
return RTMP_CID_OverStream;
}
int SrsPlayResPacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -4073,11 +4002,6 @@ void SrsOnBWDonePacket::set_args(SrsAmf0Any *v)
args = v;
}
int SrsOnBWDonePacket::get_prefer_cid()
{
return RTMP_CID_OverConnection;
}
int SrsOnBWDonePacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -4133,11 +4057,6 @@ void SrsOnStatusCallPacket::set_data(SrsAmf0Object *v)
data = v;
}
int SrsOnStatusCallPacket::get_prefer_cid()
{
return RTMP_CID_OverStream;
}
int SrsOnStatusCallPacket::get_message_type()
{
return RTMP_MSG_AMF0CommandMessage;
@ -4188,11 +4107,6 @@ void SrsOnStatusDataPacket::set_data(SrsAmf0Object *v)
data = v;
}
int SrsOnStatusDataPacket::get_prefer_cid()
{
return RTMP_CID_OverStream;
}
int SrsOnStatusDataPacket::get_message_type()
{
return RTMP_MSG_AMF0DataMessage;
@ -4218,33 +4132,28 @@ srs_error_t SrsOnStatusDataPacket::encode_packet(SrsBuffer *stream)
return err;
}
SrsSampleAccessPacket::SrsSampleAccessPacket()
SrsNaluSampleAccessPacket::SrsNaluSampleAccessPacket()
{
command_name = RTMP_AMF0_DATA_SAMPLE_ACCESS;
video_sample_access = false;
audio_sample_access = false;
}
SrsSampleAccessPacket::~SrsSampleAccessPacket()
SrsNaluSampleAccessPacket::~SrsNaluSampleAccessPacket()
{
}
int SrsSampleAccessPacket::get_prefer_cid()
{
return RTMP_CID_OverStream;
}
int SrsSampleAccessPacket::get_message_type()
int SrsNaluSampleAccessPacket::get_message_type()
{
return RTMP_MSG_AMF0DataMessage;
}
int SrsSampleAccessPacket::get_size()
int SrsNaluSampleAccessPacket::get_size()
{
return SrsAmf0Size::str(command_name) + SrsAmf0Size::boolean() + SrsAmf0Size::boolean();
}
srs_error_t SrsSampleAccessPacket::encode_packet(SrsBuffer *stream)
srs_error_t SrsNaluSampleAccessPacket::encode_packet(SrsBuffer *stream)
{
srs_error_t err = srs_success;
@ -4326,11 +4235,6 @@ srs_error_t SrsOnMetaDataPacket::decode(SrsBuffer *stream)
return err;
}
int SrsOnMetaDataPacket::get_prefer_cid()
{
return RTMP_CID_OverConnection2;
}
int SrsOnMetaDataPacket::get_message_type()
{
return RTMP_MSG_AMF0DataMessage;
@ -4378,11 +4282,6 @@ srs_error_t SrsSetWindowAckSizePacket::decode(SrsBuffer *stream)
return err;
}
int SrsSetWindowAckSizePacket::get_prefer_cid()
{
return RTMP_CID_ProtocolControl;
}
int SrsSetWindowAckSizePacket::get_message_type()
{
return RTMP_MSG_WindowAcknowledgementSize;
@ -4428,11 +4327,6 @@ srs_error_t SrsAcknowledgementPacket::decode(SrsBuffer *stream)
return err;
}
int SrsAcknowledgementPacket::get_prefer_cid()
{
return RTMP_CID_ProtocolControl;
}
int SrsAcknowledgementPacket::get_message_type()
{
return RTMP_MSG_Acknowledgement;
@ -4478,11 +4372,6 @@ srs_error_t SrsSetChunkSizePacket::decode(SrsBuffer *stream)
return err;
}
int SrsSetChunkSizePacket::get_prefer_cid()
{
return RTMP_CID_ProtocolControl;
}
int SrsSetChunkSizePacket::get_message_type()
{
return RTMP_MSG_SetChunkSize;
@ -4516,11 +4405,6 @@ SrsSetPeerBandwidthPacket::~SrsSetPeerBandwidthPacket()
{
}
int SrsSetPeerBandwidthPacket::get_prefer_cid()
{
return RTMP_CID_ProtocolControl;
}
int SrsSetPeerBandwidthPacket::get_message_type()
{
return RTMP_MSG_SetPeerBandwidth;
@ -4588,11 +4472,6 @@ srs_error_t SrsUserControlPacket::decode(SrsBuffer *stream)
return err;
}
int SrsUserControlPacket::get_prefer_cid()
{
return RTMP_CID_ProtocolControl;
}
int SrsUserControlPacket::get_message_type()
{
return RTMP_MSG_UserControlMessage;

124
trunk/src/protocol/srs_protocol_rtmp_stack.hpp
View File

@ -28,7 +28,7 @@ class SrsBuffer;
class SrsAmf0Any;
class SrsMessageHeader;
class SrsChunkStream;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsProtocol;
class ISrsProtocolReader;
@ -39,7 +39,7 @@ class SrsPublishPacket;
class SrsOnMetaDataPacket;
class SrsPlayPacket;
class SrsCommonMessage;
class SrsPacket;
class SrsRtmpCommand;
class SrsAmf0Object;
class IMergeReadHandler;
class SrsCallPacket;
@ -86,17 +86,17 @@ class SrsCallPacket;
#define StatusCodeDataStart "NetStream.Data.Start"
#define StatusCodeUnpublishSuccess "NetStream.Unpublish.Success"
// The decoded message payload.
// The message payload is decoded as RTMP packet.
// @remark we seperate the packet from message,
// for the packet focus on logic and domain data,
// the message bind to the protocol and focus on protocol, such as header.
// we can merge the message and packet, using OOAD hierachy, packet extends from message,
// it's better for me to use components -- the message use the packet as payload.
class SrsPacket
class SrsRtmpCommand
{
public:
SrsPacket();
virtual ~SrsPacket();
SrsRtmpCommand();
virtual ~SrsRtmpCommand();
public:
// Covert packet to common message.
@ -115,11 +115,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
// The cid(chunk id) specifies the chunk to send data over.
// Generally, each message prefer some cid, for example,
// all protocol control messages prefer RTMP_CID_ProtocolControl,
// SrsSetWindowAckSizePacket is protocol control message.
virtual int get_prefer_cid();
// The subpacket must override to provide the right message type.
// The message type set the RTMP message type in header.
virtual int get_message_type();
@ -182,7 +177,7 @@ private:
// default to true for it's very easy to use the protocol stack.
bool auto_response_when_recv;
// When not auto response message, manual flush the messages in queue.
std::vector<SrsPacket *> manual_response_queue;
std::vector<SrsRtmpCommand *> manual_response_queue;
// For peer out
private:
// Cache for multiple messages send,
@ -266,26 +261,26 @@ public:
// @param ppacket, output decoded packet,
// always NULL if error, never NULL if success.
// @return error when unknown packet, error when decode failed.
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsPacket **ppacket);
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket);
// Send the RTMP message and always free it.
// user must never free or use the msg after this method,
// For it will always free the msg.
// @param msg, the msg to send out, never be NULL.
// @param stream_id, the stream id of packet to send over, 0 for control message.
virtual srs_error_t send_and_free_message(SrsSharedPtrMessage *msg, int stream_id);
virtual srs_error_t send_and_free_message(SrsMediaPacket *msg, int stream_id);
// Send the RTMP message and always free it.
// user must never free or use the msg after this method,
// For it will always free the msg.
// @param msgs, the msgs to send out, never be NULL.
// @param nb_msgs, the size of msgs to send out.
// @param stream_id, the stream id of packet to send over, 0 for control message.
virtual srs_error_t send_and_free_messages(SrsSharedPtrMessage **msgs, int nb_msgs, int stream_id);
virtual srs_error_t send_and_free_messages(SrsMediaPacket **msgs, int nb_msgs, int stream_id);
// Send the RTMP packet and always free it.
// user must never free or use the packet after this method,
// For it will always free the packet.
// @param packet, the packet to send out, never be NULL.
// @param stream_id, the stream id of packet to send over, 0 for control message.
virtual srs_error_t send_and_free_packet(SrsPacket *packet, int stream_id);
virtual srs_error_t send_and_free_packet(SrsRtmpCommand *packet, int stream_id);
public:
// Expect a specified message, drop others util got specified one.
@ -317,7 +312,7 @@ public:
return srs_error_wrap(err, "recv message");
}
SrsPacket *packet = NULL;
SrsRtmpCommand *packet = NULL;
if ((err = decode_message(msg, &packet)) != srs_success) {
srs_freep(msg);
srs_freep(packet);
@ -342,13 +337,13 @@ public:
private:
// Send out the messages, donot free it,
// The caller must free the param msgs.
virtual srs_error_t do_send_messages(SrsSharedPtrMessage **msgs, int nb_msgs);
virtual srs_error_t do_send_messages(SrsMediaPacket **msgs, int nb_msgs);
// Send iovs. send multiple times if exceed limits.
virtual srs_error_t do_iovs_send(iovec *iovs, int size);
// The underlayer api for send and free packet.
virtual srs_error_t do_send_and_free_packet(SrsPacket *packet, int stream_id);
virtual srs_error_t do_send_and_free_packet(SrsRtmpCommand *packet, int stream_id);
// The imp for decode_message
virtual srs_error_t do_decode_message(SrsMessageHeader &header, SrsBuffer *stream, SrsPacket **ppacket);
virtual srs_error_t do_decode_message(SrsMessageHeader &header, SrsBuffer *stream, SrsRtmpCommand **ppacket);
// Recv bytes oriented RTMP message from protocol stack.
// return error if error occur and nerver set the pmsg,
// return success and pmsg set to NULL if no entire message got,
@ -366,7 +361,7 @@ private:
// When recv message, update the context.
virtual srs_error_t on_recv_message(SrsCommonMessage *msg);
// When message sentout, update the context.
virtual srs_error_t on_send_packet(SrsMessageHeader *mh, SrsPacket *packet);
virtual srs_error_t on_send_packet(SrsMessageHeader *mh, SrsRtmpCommand *packet);
private:
// Auto response the ack message.
@ -604,10 +599,10 @@ public:
virtual int64_t get_recv_bytes();
virtual int64_t get_send_bytes();
virtual srs_error_t recv_message(SrsCommonMessage **pmsg);
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsPacket **ppacket);
virtual srs_error_t send_and_free_message(SrsSharedPtrMessage *msg, int stream_id);
virtual srs_error_t send_and_free_messages(SrsSharedPtrMessage **msgs, int nb_msgs, int stream_id);
virtual srs_error_t send_and_free_packet(SrsPacket *packet, int stream_id);
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket);
virtual srs_error_t send_and_free_message(SrsMediaPacket *msg, int stream_id);
virtual srs_error_t send_and_free_messages(SrsMediaPacket **msgs, int nb_msgs, int stream_id);
virtual srs_error_t send_and_free_packet(SrsRtmpCommand *packet, int stream_id);
public:
// handshake with server, try complex, then simple handshake.
@ -717,13 +712,13 @@ public:
// @param ppacket, output decoded packet,
// always NULL if error, never NULL if success.
// @return error when unknown packet, error when decode failed.
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsPacket **ppacket);
virtual srs_error_t decode_message(SrsCommonMessage *msg, SrsRtmpCommand **ppacket);
// Send the RTMP message and always free it.
// user must never free or use the msg after this method,
// For it will always free the msg.
// @param msg, the msg to send out, never be NULL.
// @param stream_id, the stream id of packet to send over, 0 for control message.
virtual srs_error_t send_and_free_message(SrsSharedPtrMessage *msg, int stream_id);
virtual srs_error_t send_and_free_message(SrsMediaPacket *msg, int stream_id);
// Send the RTMP message and always free it.
// user must never free or use the msg after this method,
// For it will always free the msg.
@ -732,13 +727,13 @@ public:
// @param stream_id, the stream id of packet to send over, 0 for control message.
//
// @remark performance issue, to support 6k+ 250kbps client,
virtual srs_error_t send_and_free_messages(SrsSharedPtrMessage **msgs, int nb_msgs, int stream_id);
virtual srs_error_t send_and_free_messages(SrsMediaPacket **msgs, int nb_msgs, int stream_id);
// Send the RTMP packet and always free it.
// user must never free or use the packet after this method,
// For it will always free the packet.
// @param packet, the packet to send out, never be NULL.
// @param stream_id, the stream id of packet to send over, 0 for control message.
virtual srs_error_t send_and_free_packet(SrsPacket *packet, int stream_id);
virtual srs_error_t send_and_free_packet(SrsRtmpCommand *packet, int stream_id);
public:
// Do handshake with client, try complex then simple.
@ -842,7 +837,7 @@ private:
// 4.1.1. connect
// The client sends the connect command to the server to request
// connection to a server application instance.
class SrsConnectAppPacket : public SrsPacket
class SrsConnectAppPacket : public SrsRtmpCommand
{
public:
// Name of the command. Set to "connect".
@ -866,7 +861,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -874,7 +868,7 @@ protected:
virtual srs_error_t encode_packet(SrsBuffer *stream);
};
// Response for SrsConnectAppPacket.
class SrsConnectAppResPacket : public SrsPacket
class SrsConnectAppResPacket : public SrsRtmpCommand
{
public:
// The _result or _error; indicates whether the response is result or error.
@ -897,7 +891,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -909,7 +902,7 @@ protected:
// The call method of the NetConnection object runs remote procedure
// calls (RPC) at the receiving end. The called RPC name is passed as a
// parameter to the call command.
class SrsCallPacket : public SrsPacket
class SrsCallPacket : public SrsRtmpCommand
{
public:
// Name of the remote procedure that is called.
@ -932,7 +925,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -940,7 +932,7 @@ protected:
virtual srs_error_t encode_packet(SrsBuffer *stream);
};
// Response for SrsCallPacket.
class SrsCallResPacket : public SrsPacket
class SrsCallResPacket : public SrsRtmpCommand
{
public:
// Name of the command.
@ -959,7 +951,6 @@ public:
virtual ~SrsCallResPacket();
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -972,7 +963,7 @@ protected:
// channel for message communication The publishing of audio, video, and
// metadata is carried out over stream channel created using the
// createStream command.
class SrsCreateStreamPacket : public SrsPacket
class SrsCreateStreamPacket : public SrsRtmpCommand
{
public:
// Name of the command. Set to "createStream".
@ -993,7 +984,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1001,7 +991,7 @@ protected:
virtual srs_error_t encode_packet(SrsBuffer *stream);
};
// Response for SrsCreateStreamPacket.
class SrsCreateStreamResPacket : public SrsPacket
class SrsCreateStreamResPacket : public SrsRtmpCommand
{
public:
// The _result or _error; indicates whether the response is result or error.
@ -1022,7 +1012,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1031,7 +1020,7 @@ protected:
};
// client close stream packet.
class SrsCloseStreamPacket : public SrsPacket
class SrsCloseStreamPacket : public SrsRtmpCommand
{
public:
// Name of the command, set to "closeStream".
@ -1050,7 +1039,7 @@ public:
};
// FMLE start publish: ReleaseStream/PublishStream/FCPublish/FCUnpublish
class SrsFMLEStartPacket : public SrsPacket
class SrsFMLEStartPacket : public SrsRtmpCommand
{
public:
// Name of the command
@ -1074,7 +1063,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1086,7 +1074,7 @@ public:
static SrsFMLEStartPacket *create_FC_publish(std::string stream);
};
// Response for SrsFMLEStartPacket.
class SrsFMLEStartResPacket : public SrsPacket
class SrsFMLEStartResPacket : public SrsRtmpCommand
{
public:
// Name of the command
@ -1111,7 +1099,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1124,7 +1111,7 @@ protected:
// The client sends the publish command to publish a named stream to the
// server. Using this name, any client can play this stream and receive
// The published audio, video, and data messages.
class SrsPublishPacket : public SrsPacket
class SrsPublishPacket : public SrsRtmpCommand
{
public:
// Name of the command, set to "publish".
@ -1159,7 +1146,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1170,7 +1156,7 @@ protected:
// 4.2.8. pause
// The client sends the pause command to tell the server to pause or
// start playing.
class SrsPausePacket : public SrsPacket
class SrsPausePacket : public SrsRtmpCommand
{
public:
// Name of the command, set to "pause".
@ -1198,7 +1184,7 @@ public:
// 4.2.1. play
// The client sends this command to the server to play a stream.
class SrsPlayPacket : public SrsPacket
class SrsPlayPacket : public SrsRtmpCommand
{
public:
// Name of the command. Set to "play".
@ -1253,7 +1239,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1263,7 +1248,7 @@ protected:
// Response for SrsPlayPacket.
// @remark, user must set the stream_id in header.
class SrsPlayResPacket : public SrsPacket
class SrsPlayResPacket : public SrsRtmpCommand
{
public:
// Name of the command. If the play command is successful, the command
@ -1289,7 +1274,6 @@ public:
void set_desc(SrsAmf0Object *v);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1298,7 +1282,7 @@ protected:
};
// When bandwidth test done, notice client.
class SrsOnBWDonePacket : public SrsPacket
class SrsOnBWDonePacket : public SrsRtmpCommand
{
public:
// Name of command. Set to "onBWDone"
@ -1316,7 +1300,6 @@ public:
void set_args(SrsAmf0Any *v);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1326,7 +1309,7 @@ protected:
// onStatus command, AMF0 Call
// @remark, user must set the stream_id by SrsCommonMessage.set_packet().
class SrsOnStatusCallPacket : public SrsPacket
class SrsOnStatusCallPacket : public SrsRtmpCommand
{
public:
// Name of command. Set to "onStatus"
@ -1350,7 +1333,6 @@ public:
void set_data(SrsAmf0Object *v);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1360,7 +1342,7 @@ protected:
// onStatus data, AMF0 Data
// @remark, user must set the stream_id by SrsCommonMessage.set_packet().
class SrsOnStatusDataPacket : public SrsPacket
class SrsOnStatusDataPacket : public SrsRtmpCommand
{
public:
// Name of command. Set to "onStatus"
@ -1379,7 +1361,6 @@ public:
SrsAmf0Object *get_data();
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1389,7 +1370,7 @@ protected:
// AMF0Data RtmpSampleAccess
// @remark, user must set the stream_id by SrsCommonMessage.set_packet().
class SrsSampleAccessPacket : public SrsPacket
class SrsNaluSampleAccessPacket : public SrsRtmpCommand
{
public:
// Name of command. Set to "|RtmpSampleAccess".
@ -1402,11 +1383,10 @@ public:
bool audio_sample_access;
public:
SrsSampleAccessPacket();
virtual ~SrsSampleAccessPacket();
SrsNaluSampleAccessPacket();
virtual ~SrsNaluSampleAccessPacket();
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1417,7 +1397,7 @@ protected:
// The stream metadata.
// FMLE: @setDataFrame
// others: onMetaData
class SrsOnMetaDataPacket : public SrsPacket
class SrsOnMetaDataPacket : public SrsRtmpCommand
{
public:
// Name of metadata. Set to "onMetaData"
@ -1437,7 +1417,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1448,7 +1427,7 @@ protected:
// 5.5. Window Acknowledgement Size (5)
// The client or the server sends this message to inform the peer which
// window size to use when sending acknowledgment.
class SrsSetWindowAckSizePacket : public SrsPacket
class SrsSetWindowAckSizePacket : public SrsRtmpCommand
{
public:
int32_t ackowledgement_window_size;
@ -1461,7 +1440,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1472,7 +1450,7 @@ protected:
// 5.3. Acknowledgement (3)
// The client or the server sends the acknowledgment to the peer after
// receiving bytes equal to the window size.
class SrsAcknowledgementPacket : public SrsPacket
class SrsAcknowledgementPacket : public SrsRtmpCommand
{
public:
uint32_t sequence_number;
@ -1485,7 +1463,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1496,7 +1473,7 @@ protected:
// 7.1. Set Chunk Size
// Protocol control message 1, Set Chunk Size, is used to notify the
// peer about the new maximum chunk size.
class SrsSetChunkSizePacket : public SrsPacket
class SrsSetChunkSizePacket : public SrsRtmpCommand
{
public:
// The maximum chunk size can be 65536 bytes. The chunk size is
@ -1511,7 +1488,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1531,7 +1507,7 @@ enum SrsPeerBandwidthType {
// 5.6. Set Peer Bandwidth (6)
// The client or the server sends this message to update the output
// bandwidth of the peer.
class SrsSetPeerBandwidthPacket : public SrsPacket
class SrsSetPeerBandwidthPacket : public SrsRtmpCommand
{
public:
int32_t bandwidth;
@ -1543,7 +1519,6 @@ public:
virtual ~SrsSetPeerBandwidthPacket();
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:
@ -1634,7 +1609,7 @@ enum SrcPCUCEventType {
// | Event Type ( 2- bytes ) | Event Data
// +------------------------------+-------------------------
// Figure 5 Pay load for the 'User Control Message'.
class SrsUserControlPacket : public SrsPacket
class SrsUserControlPacket : public SrsRtmpCommand
{
public:
// Event type is followed by Event data.
@ -1655,7 +1630,6 @@ public:
virtual srs_error_t decode(SrsBuffer *stream);
// Encode functions for concrete packet to override.
public:
virtual int get_prefer_cid();
virtual int get_message_type();
protected:

12
trunk/src/protocol/srs_protocol_rtp.cpp
View File

@ -36,7 +36,7 @@ srs_error_t SrsRtpVideoBuilder::initialize(SrsFormat *format, uint32_t ssrc, uin
return srs_success;
}
srs_error_t SrsRtpVideoBuilder::package_stap_a(SrsSharedPtrMessage *msg, SrsRtpPacket *pkt)
srs_error_t SrsRtpVideoBuilder::package_stap_a(SrsMediaPacket *msg, SrsRtpPacket *pkt)
{
srs_error_t err = srs_success;
@ -86,7 +86,7 @@ srs_error_t SrsRtpVideoBuilder::package_stap_a(SrsSharedPtrMessage *msg, SrsRtpP
for (vector<vector<char> *>::iterator it = params.begin(); it != params.end(); ++it) {
vector<char> *param = *it;
SrsSample *sample = new SrsSample();
SrsNaluSample *sample = new SrsNaluSample();
sample->bytes = payload;
sample->size = param->size();
if (format->vcodec->id == SrsVideoCodecIdHEVC) {
@ -102,7 +102,7 @@ srs_error_t SrsRtpVideoBuilder::package_stap_a(SrsSharedPtrMessage *msg, SrsRtpP
return err;
}
srs_error_t SrsRtpVideoBuilder::package_nalus(SrsSharedPtrMessage *msg, const vector<SrsSample *> &samples, vector<SrsRtpPacket *> &pkts)
srs_error_t SrsRtpVideoBuilder::package_nalus(SrsMediaPacket *msg, const vector<SrsNaluSample *> &samples, vector<SrsRtpPacket *> &pkts)
{
srs_error_t err = srs_success;
@ -116,7 +116,7 @@ srs_error_t SrsRtpVideoBuilder::package_nalus(SrsSharedPtrMessage *msg, const ve
uint8_t first_nalu_type = 0;
for (int i = 0; i < (int)samples.size(); i++) {
SrsSample *sample = samples[i];
SrsNaluSample *sample = samples[i];
if (!sample->size) {
continue;
@ -212,7 +212,7 @@ srs_error_t SrsRtpVideoBuilder::package_nalus(SrsSharedPtrMessage *msg, const ve
}
// Single NAL Unit Packet @see https://tools.ietf.org/html/rfc6184#section-5.6
srs_error_t SrsRtpVideoBuilder::package_single_nalu(SrsSharedPtrMessage *msg, SrsSample *sample, vector<SrsRtpPacket *> &pkts)
srs_error_t SrsRtpVideoBuilder::package_single_nalu(SrsMediaPacket *msg, SrsNaluSample *sample, vector<SrsRtpPacket *> &pkts)
{
srs_error_t err = srs_success;
@ -236,7 +236,7 @@ srs_error_t SrsRtpVideoBuilder::package_single_nalu(SrsSharedPtrMessage *msg, Sr
return err;
}
srs_error_t SrsRtpVideoBuilder::package_fu_a(SrsSharedPtrMessage *msg, SrsSample *sample, int fu_payload_size, vector<SrsRtpPacket *> &pkts)
srs_error_t SrsRtpVideoBuilder::package_fu_a(SrsMediaPacket *msg, SrsNaluSample *sample, int fu_payload_size, vector<SrsRtpPacket *> &pkts)
{
srs_error_t err = srs_success;

12
trunk/src/protocol/srs_protocol_rtp.hpp
View File

@ -16,8 +16,8 @@
#include <srs_kernel_flv.hpp>
#include <srs_kernel_rtc_rtp.hpp>
class SrsSharedPtrMessage;
class SrsSample;
class SrsMediaPacket;
class SrsNaluSample;
class SrsRtpPacket;
class SrsFormat;
@ -36,10 +36,10 @@ public:
public:
srs_error_t initialize(SrsFormat *format, uint32_t ssrc, uint8_t payload_type);
srs_error_t package_stap_a(SrsSharedPtrMessage *msg, SrsRtpPacket *pkt);
srs_error_t package_nalus(SrsSharedPtrMessage *msg, const std::vector<SrsSample *> &samples, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_single_nalu(SrsSharedPtrMessage *msg, SrsSample *sample, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_fu_a(SrsSharedPtrMessage *msg, SrsSample *sample, int fu_payload_size, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_stap_a(SrsMediaPacket *msg, SrsRtpPacket *pkt);
srs_error_t package_nalus(SrsMediaPacket *msg, const std::vector<SrsNaluSample *> &samples, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_single_nalu(SrsMediaPacket *msg, SrsNaluSample *sample, std::vector<SrsRtpPacket *> &pkts);
srs_error_t package_fu_a(SrsMediaPacket *msg, SrsNaluSample *sample, int fu_payload_size, std::vector<SrsRtpPacket *> &pkts);
};
#endif

2
trunk/src/protocol/srs_protocol_rtsp_stack.hpp
View File

@ -15,7 +15,7 @@
class SrsBuffer;
class SrsSimpleStream;
class SrsAudioFrame;
class SrsParsedAudioPacket;
class ISrsProtocolReadWriter;
// From rtsp specification

24
trunk/src/protocol/srs_protocol_utility.cpp
View File

@ -283,19 +283,18 @@ string srs_net_url_encode_rtmp_url(string server, int port, string host, string
return url;
}
template <typename T>
srs_error_t srs_do_rtmp_create_msg(char type, uint32_t timestamp, char *data, int size, int stream_id, T **ppmsg)
srs_error_t srs_do_rtmp_create_msg(char type, uint32_t timestamp, char *data, int size, int stream_id, SrsCommonMessage **ppmsg)
{
srs_error_t err = srs_success;
*ppmsg = NULL;
T *msg = NULL;
SrsCommonMessage *msg = NULL;
if (type == SrsFrameTypeAudio) {
SrsMessageHeader header;
header.initialize_audio(size, timestamp, stream_id);
msg = new T();
msg = new SrsCommonMessage();
if ((err = msg->create(&header, data, size)) != srs_success) {
srs_freep(msg);
return srs_error_wrap(err, "create message");
@ -304,7 +303,7 @@ srs_error_t srs_do_rtmp_create_msg(char type, uint32_t timestamp, char *data, in
SrsMessageHeader header;
header.initialize_video(size, timestamp, stream_id);
msg = new T();
msg = new SrsCommonMessage();
if ((err = msg->create(&header, data, size)) != srs_success) {
srs_freep(msg);
return srs_error_wrap(err, "create message");
@ -313,7 +312,7 @@ srs_error_t srs_do_rtmp_create_msg(char type, uint32_t timestamp, char *data, in
SrsMessageHeader header;
header.initialize_amf0_script(size, stream_id);
msg = new T();
msg = new SrsCommonMessage();
if ((err = msg->create(&header, data, size)) != srs_success) {
srs_freep(msg);
return srs_error_wrap(err, "create message");
@ -327,19 +326,6 @@ srs_error_t srs_do_rtmp_create_msg(char type, uint32_t timestamp, char *data, in
return err;
}
srs_error_t srs_rtmp_create_msg(char type, uint32_t timestamp, char *data, int size, int stream_id, SrsSharedPtrMessage **ppmsg)
{
srs_error_t err = srs_success;
// only when failed, we must free the data.
if ((err = srs_do_rtmp_create_msg(type, timestamp, data, size, stream_id, ppmsg)) != srs_success) {
srs_freepa(data);
return srs_error_wrap(err, "create message");
}
return err;
}
srs_error_t srs_rtmp_create_msg(char type, uint32_t timestamp, char *data, int size, int stream_id, SrsCommonMessage **ppmsg)
{
srs_error_t err = srs_success;

3
trunk/src/protocol/srs_protocol_utility.hpp
View File

@ -32,7 +32,7 @@
class ISrsHttpMessage;
class SrsMessageHeader;
class SrsSharedPtrMessage;
class SrsMediaPacket;
class SrsCommonMessage;
class ISrsProtocolReadWriter;
class ISrsReader;
@ -101,7 +101,6 @@ extern std::string srs_net_url_encode_rtmp_url(std::string server, int port, std
* @param data the packet bytes. user should never free it.
* @param ppmsg output the shared ptr message. user should free it.
*/
extern srs_error_t srs_rtmp_create_msg(char type, uint32_t timestamp, char *data, int size, int stream_id, SrsSharedPtrMessage **ppmsg);
extern srs_error_t srs_rtmp_create_msg(char type, uint32_t timestamp, char *data, int size, int stream_id, SrsCommonMessage **ppmsg);
// write large numbers of iovs.

64
trunk/src/utest/srs_utest_fmp4.cpp
View File

@ -54,25 +54,25 @@ public:
virtual ~MockSrsFormat() {}
};
class MockSrsSharedPtrMessage : public SrsSharedPtrMessage
class MockSrsMediaPacket : public SrsMediaPacket
{
public:
MockSrsSharedPtrMessage(bool is_video_msg, uint32_t ts)
MockSrsMediaPacket(bool is_video_msg, uint32_t ts)
{
timestamp = ts;
// Create sample payload
char *payload = new char[1024];
memset(payload, 0x00, 1024);
SrsSharedPtrMessage::wrap(payload, 1024);
SrsMediaPacket::wrap(payload, 1024);
if (is_video_msg) {
message_type = RTMP_MSG_VideoMessage;
message_type = SrsFrameTypeVideo;
} else {
message_type = RTMP_MSG_AudioMessage;
message_type = SrsFrameTypeAudio;
}
}
virtual ~MockSrsSharedPtrMessage() {}
virtual ~MockSrsMediaPacket() {}
};
VOID TEST(Fmp4Test, SrsInitMp4Segment_VideoOnly)
@ -165,11 +165,11 @@ VOID TEST(Fmp4Test, SrsHlsM4sSegment_Basic)
// Write video sample
MockSrsFormat fmt;
MockSrsSharedPtrMessage video_msg(true, 1000);
MockSrsMediaPacket video_msg(true, 1000);
HELPER_ASSERT_SUCCESS(segment.write(&video_msg, &fmt));
// Write audio sample
MockSrsSharedPtrMessage audio_msg(false, 2000); // Different timestamp
MockSrsMediaPacket audio_msg(false, 2000); // Different timestamp
HELPER_ASSERT_SUCCESS(segment.write(&audio_msg, &fmt));
// Test duration - should be > 0 after writing samples with different timestamps
@ -199,10 +199,10 @@ VOID TEST(Fmp4Test, SrsHlsM4sSegment_WithEncryption)
// Write samples with different timestamps to create duration
MockSrsFormat fmt;
MockSrsSharedPtrMessage video_msg1(true, 1000);
MockSrsMediaPacket video_msg1(true, 1000);
HELPER_ASSERT_SUCCESS(segment.write(&video_msg1, &fmt));
MockSrsSharedPtrMessage video_msg2(true, 2000);
MockSrsMediaPacket video_msg2(true, 2000);
HELPER_ASSERT_SUCCESS(segment.write(&video_msg2, &fmt));
// Test that segment has content
@ -330,19 +330,19 @@ VOID TEST(Fmp4Test, SrsHlsFmp4Muxer_WriteMedia)
HELPER_ASSERT_SUCCESS(muxer.write_init_mp4(&fmt, true, true));
// Write video samples
MockSrsSharedPtrMessage video_msg(true, 1000);
MockSrsMediaPacket video_msg(true, 1000);
HELPER_ASSERT_SUCCESS(muxer.write_video(&video_msg, &fmt));
// Write audio samples
MockSrsSharedPtrMessage audio_msg(false, 1000);
MockSrsMediaPacket audio_msg(false, 1000);
HELPER_ASSERT_SUCCESS(muxer.write_audio(&audio_msg, &fmt));
// Write more samples with time progression to accumulate duration
for (int i = 1; i <= 5; i++) {
MockSrsSharedPtrMessage video_msg2(true, 1000 + i * 1000); // 1 second increments
MockSrsMediaPacket video_msg2(true, 1000 + i * 1000); // 1 second increments
HELPER_ASSERT_SUCCESS(muxer.write_video(&video_msg2, &fmt));
MockSrsSharedPtrMessage audio_msg2(false, 1000 + i * 1000);
MockSrsMediaPacket audio_msg2(false, 1000 + i * 1000);
HELPER_ASSERT_SUCCESS(muxer.write_audio(&audio_msg2, &fmt));
}
@ -385,17 +385,17 @@ VOID TEST(Fmp4Test, SrsHlsMp4Controller_PublishWorkflow)
// Handle sequence headers
MockSrsFormat fmt;
MockSrsSharedPtrMessage video_sh(true, 0);
MockSrsMediaPacket video_sh(true, 0);
HELPER_ASSERT_SUCCESS(controller.on_sequence_header(&video_sh, &fmt));
MockSrsSharedPtrMessage audio_sh(false, 0);
MockSrsMediaPacket audio_sh(false, 0);
HELPER_ASSERT_SUCCESS(controller.on_sequence_header(&audio_sh, &fmt));
// Write media samples
MockSrsSharedPtrMessage video_msg(true, 1000);
MockSrsMediaPacket video_msg(true, 1000);
HELPER_ASSERT_SUCCESS(controller.write_video(&video_msg, &fmt));
MockSrsSharedPtrMessage audio_msg(false, 1000);
MockSrsMediaPacket audio_msg(false, 1000);
HELPER_ASSERT_SUCCESS(controller.write_audio(&audio_msg, &fmt));
// Unpublish
@ -601,13 +601,13 @@ VOID TEST(Fmp4Test, Integration_FullEncryptionWorkflow)
m4s_segment.config_cipher(seg_key, seg_iv);
// Write samples to encrypted segment with time progression
MockSrsSharedPtrMessage video_msg1(true, 2000);
MockSrsMediaPacket video_msg1(true, 2000);
HELPER_ASSERT_SUCCESS(m4s_segment.write(&video_msg1, &fmt));
MockSrsSharedPtrMessage audio_msg1(false, 2500);
MockSrsMediaPacket audio_msg1(false, 2500);
HELPER_ASSERT_SUCCESS(m4s_segment.write(&audio_msg1, &fmt));
MockSrsSharedPtrMessage video_msg2(true, 3000);
MockSrsMediaPacket video_msg2(true, 3000);
HELPER_ASSERT_SUCCESS(m4s_segment.write(&video_msg2, &fmt));
// Should have duration from timestamp progression
@ -720,11 +720,11 @@ VOID TEST(Fmp4Test, Configuration_TrackIdManagement)
HELPER_ASSERT_SUCCESS(controller.on_publish(&req));
MockSrsFormat fmt;
MockSrsSharedPtrMessage video_sh(true, 0);
MockSrsMediaPacket video_sh(true, 0);
HELPER_ASSERT_SUCCESS(controller.on_sequence_header(&video_sh, &fmt));
EXPECT_TRUE(controller.has_video_sh_);
MockSrsSharedPtrMessage audio_sh(false, 0);
MockSrsMediaPacket audio_sh(false, 0);
HELPER_ASSERT_SUCCESS(controller.on_sequence_header(&audio_sh, &fmt));
EXPECT_TRUE(controller.has_audio_sh_);
@ -740,7 +740,7 @@ VOID TEST(Fmp4Test, Configuration_SequenceHeaderValidation)
// Test sequence header without request (should fail)
MockSrsFormat fmt;
MockSrsSharedPtrMessage video_sh(true, 0);
MockSrsMediaPacket video_sh(true, 0);
HELPER_EXPECT_FAILED(controller.on_sequence_header(&video_sh, &fmt));
// Set request and try again
@ -765,14 +765,14 @@ VOID TEST(Fmp4Test, CodecDetection_AudioCodecUpdate)
MockSrsFormat fmt;
fmt.acodec = new SrsAudioCodecConfig();
fmt.acodec->id = SrsAudioCodecIdAAC;
fmt.audio = new SrsAudioFrame();
fmt.audio = new SrsParsedAudioPacket();
fmt.audio->codec = fmt.acodec;
// Initial codec should be forbidden (not set)
EXPECT_EQ(SrsAudioCodecIdForbidden, controller.muxer_->latest_acodec());
// Write audio frame - should detect and update codec
MockSrsSharedPtrMessage audio_msg(false, 1000);
MockSrsMediaPacket audio_msg(false, 1000);
HELPER_ASSERT_SUCCESS(controller.write_audio(&audio_msg, &fmt));
// Codec should now be detected as AAC
@ -804,14 +804,14 @@ VOID TEST(Fmp4Test, CodecDetection_VideoCodecUpdate)
MockSrsFormat fmt;
fmt.vcodec = new SrsVideoCodecConfig();
fmt.vcodec->id = SrsVideoCodecIdAVC;
fmt.video = new SrsVideoFrame();
fmt.video = new SrsParsedVideoPacket();
fmt.video->codec = fmt.vcodec;
// Initial codec should be forbidden (not set)
EXPECT_EQ(SrsVideoCodecIdForbidden, controller.muxer_->latest_vcodec());
// Write video frame - should detect and update codec
MockSrsSharedPtrMessage video_msg(true, 1000);
MockSrsMediaPacket video_msg(true, 1000);
HELPER_ASSERT_SUCCESS(controller.write_video(&video_msg, &fmt));
// Codec should now be detected as H.264
@ -847,11 +847,11 @@ VOID TEST(Fmp4Test, Performance_MultipleSegments)
// Write many samples to create multiple segments
for (int i = 0; i < 500; i++) {
MockSrsSharedPtrMessage video_msg(true, i * 40);
MockSrsMediaPacket video_msg(true, i * 40);
HELPER_ASSERT_SUCCESS(muxer.write_video(&video_msg, &fmt));
if (i % 2 == 0) { // Write audio less frequently
MockSrsSharedPtrMessage audio_msg(false, i * 40);
MockSrsMediaPacket audio_msg(false, i * 40);
HELPER_ASSERT_SUCCESS(muxer.write_audio(&audio_msg, &fmt));
}
}
@ -876,13 +876,13 @@ VOID TEST(Fmp4Test, Compatibility_SequenceHeaderIgnore)
MockSrsFormat fmt;
// Create audio sequence header message
MockSrsSharedPtrMessage audio_sh(false, 0);
MockSrsMediaPacket audio_sh(false, 0);
// Should ignore sequence headers in write_audio
HELPER_ASSERT_SUCCESS(controller.write_audio(&audio_sh, &fmt));
// Regular audio message should be processed
MockSrsSharedPtrMessage audio_msg(false, 1000);
MockSrsMediaPacket audio_msg(false, 1000);
HELPER_ASSERT_SUCCESS(controller.write_audio(&audio_msg, &fmt));
controller.dispose();

308
trunk/src/utest/srs_utest_kernel.cpp
View File

@ -966,10 +966,12 @@ VOID TEST(KernelFLVTest, CoverWriterErrorCase)
SrsMessageHeader h;
h.initialize_video(10, 30, 20);
SrsSharedPtrMessage msg;
HELPER_EXPECT_SUCCESS(msg.create(&h, new char[1], 1));
SrsMediaPacket msg;
SrsCommonMessage common_msg;
HELPER_EXPECT_SUCCESS(common_msg.create(&h, new char[1], 1));
common_msg.to_msg(&msg);
SrsSharedPtrMessage *msgs = &msg;
SrsMediaPacket *msgs = &msg;
HELPER_EXPECT_FAILED(m.write_tags(&msgs, 1));
}
@ -983,10 +985,12 @@ VOID TEST(KernelFLVTest, CoverWriterErrorCase)
SrsMessageHeader h;
h.initialize_audio(10, 30, 20);
SrsSharedPtrMessage msg;
HELPER_EXPECT_SUCCESS(msg.create(&h, new char[1], 1));
SrsMediaPacket msg;
SrsCommonMessage common_msg;
HELPER_EXPECT_SUCCESS(common_msg.create(&h, new char[1], 1));
common_msg.to_msg(&msg);
SrsSharedPtrMessage *msgs = &msg;
SrsMediaPacket *msgs = &msg;
HELPER_EXPECT_FAILED(m.write_tags(&msgs, 1));
}
@ -1000,10 +1004,12 @@ VOID TEST(KernelFLVTest, CoverWriterErrorCase)
SrsMessageHeader h;
h.initialize_amf0_script(10, 20);
SrsSharedPtrMessage msg;
HELPER_EXPECT_SUCCESS(msg.create(&h, new char[1], 1));
SrsMediaPacket msg;
SrsCommonMessage common_msg;
HELPER_EXPECT_SUCCESS(common_msg.create(&h, new char[1], 1));
common_msg.to_msg(&msg);
SrsSharedPtrMessage *msgs = &msg;
SrsMediaPacket *msgs = &msg;
HELPER_EXPECT_FAILED(m.write_tags(&msgs, 1));
}
}
@ -3483,7 +3489,7 @@ VOID TEST(KernelCodecTest, AVFrame)
srs_error_t err;
if (true) {
SrsAudioFrame f;
SrsParsedAudioPacket f;
SrsAudioCodecConfig *cc = new SrsAudioCodecConfig();
SrsUniquePtr<SrsAudioCodecConfig> cc_uptr(cc);
HELPER_EXPECT_SUCCESS(f.initialize(cc));
@ -3501,7 +3507,7 @@ VOID TEST(KernelCodecTest, AVFrame)
}
if (true) {
SrsAudioFrame f;
SrsParsedAudioPacket f;
EXPECT_TRUE(0 == f.nb_samples);
HELPER_EXPECT_SUCCESS(f.add_sample((char *)1, 0));
@ -3512,7 +3518,7 @@ VOID TEST(KernelCodecTest, AVFrame)
}
if (true) {
SrsAudioFrame f;
SrsParsedAudioPacket f;
for (int i = 0; i < SrsMaxNbSamples; i++) {
HELPER_EXPECT_SUCCESS(f.add_sample((char *)(int64_t)(i + 1), i * 10 + 1));
}
@ -3522,7 +3528,7 @@ VOID TEST(KernelCodecTest, AVFrame)
}
if (true) {
SrsVideoFrame f;
SrsParsedVideoPacket f;
SrsVideoCodecConfig *cc = new SrsVideoCodecConfig();
SrsUniquePtr<SrsVideoCodecConfig> cc_uptr(cc);
HELPER_EXPECT_SUCCESS(f.initialize(cc));
@ -3534,7 +3540,7 @@ VOID TEST(KernelCodecTest, AVFrame)
}
if (true) {
SrsVideoFrame f;
SrsParsedVideoPacket f;
SrsVideoCodecConfig *cc = new SrsVideoCodecConfig();
SrsUniquePtr<SrsVideoCodecConfig> cc_uptr(cc);
HELPER_EXPECT_SUCCESS(f.initialize(cc));
@ -3545,7 +3551,7 @@ VOID TEST(KernelCodecTest, AVFrame)
}
if (true) {
SrsVideoFrame f;
SrsParsedVideoPacket f;
SrsVideoCodecConfig *cc = new SrsVideoCodecConfig();
SrsUniquePtr<SrsVideoCodecConfig> cc_uptr(cc);
HELPER_EXPECT_SUCCESS(f.initialize(cc));
@ -3556,7 +3562,7 @@ VOID TEST(KernelCodecTest, AVFrame)
}
if (true) {
SrsVideoFrame f;
SrsParsedVideoPacket f;
SrsVideoCodecConfig *cc = new SrsVideoCodecConfig();
SrsUniquePtr<SrsVideoCodecConfig> cc_uptr(cc);
HELPER_EXPECT_SUCCESS(f.initialize(cc));
@ -3567,7 +3573,7 @@ VOID TEST(KernelCodecTest, AVFrame)
}
if (true) {
SrsVideoFrame f;
SrsParsedVideoPacket f;
SrsVideoCodecConfig *cc = new SrsVideoCodecConfig();
SrsUniquePtr<SrsVideoCodecConfig> cc_uptr(cc);
HELPER_EXPECT_SUCCESS(f.initialize(cc));
@ -3587,12 +3593,12 @@ VOID TEST(KernelCodecTest, AVFrameNoConfig)
srs_error_t err;
if (true) {
SrsAudioFrame f;
SrsParsedAudioPacket f;
HELPER_EXPECT_SUCCESS(f.add_sample((char *)1, 10));
}
if (true) {
SrsVideoFrame f;
SrsParsedVideoPacket f;
HELPER_EXPECT_SUCCESS(f.add_sample((char *)"\x05", 1));
}
}
@ -3604,39 +3610,39 @@ VOID TEST(KernelCodecTest, VideoFrameH264_ParseNaluType)
if (true) {
// I Frame
uint8_t data[] = {0x05, 0x00, 0x00, 0x00};
SrsSample sample((char *)data, sizeof(data));
SrsNaluSample sample((char *)data, sizeof(data));
SrsAvcNaluType nalu_type = SrsAvcNaluTypeForbidden;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_nalu_type(&sample, nalu_type));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_nalu_type(&sample, nalu_type));
EXPECT_EQ(nalu_type, SrsAvcNaluTypeIDR);
// P Frame
uint8_t data2[] = {0x01, 0x00, 0x00, 0x00};
SrsSample sample2((char *)data2, sizeof(data2));
SrsNaluSample sample2((char *)data2, sizeof(data2));
nalu_type = SrsAvcNaluTypeForbidden;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_nalu_type(&sample2, nalu_type));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_nalu_type(&sample2, nalu_type));
EXPECT_EQ(nalu_type, SrsAvcNaluTypeNonIDR);
// SPS
uint8_t data3[] = {0x07, 0x00, 0x00, 0x00};
SrsSample sample3((char *)data3, sizeof(data3));
SrsNaluSample sample3((char *)data3, sizeof(data3));
nalu_type = SrsAvcNaluTypeForbidden;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_nalu_type(&sample3, nalu_type));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_nalu_type(&sample3, nalu_type));
EXPECT_EQ(nalu_type, SrsAvcNaluTypeSPS);
// PPS
uint8_t data4[] = {0x08, 0x00, 0x00, 0x00};
SrsSample sample4((char *)data4, sizeof(data4));
SrsNaluSample sample4((char *)data4, sizeof(data4));
nalu_type = SrsAvcNaluTypeForbidden;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_nalu_type(&sample4, nalu_type));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_nalu_type(&sample4, nalu_type));
EXPECT_EQ(nalu_type, SrsAvcNaluTypePPS);
// Empty Sample
SrsSample empty_sample(NULL, 0);
HELPER_EXPECT_FAILED(SrsVideoFrame::parse_avc_nalu_type(&empty_sample, nalu_type));
SrsNaluSample empty_sample(NULL, 0);
HELPER_EXPECT_FAILED(SrsParsedVideoPacket::parse_avc_nalu_type(&empty_sample, nalu_type));
}
}
@ -3649,53 +3655,53 @@ VOID TEST(KernelCodecTest, VideoFrameH264_BFrameDetection_AllowedNaluTypes)
// NonIDR NALU (type 1) with B-frame slice_type=1
uint8_t data_b1[] = {0x01, 0xA8, 0x00, 0x00}; // NALU type 1, slice_type=1 (B)
SrsSample sample_b1((char *)data_b1, sizeof(data_b1));
SrsNaluSample sample_b1((char *)data_b1, sizeof(data_b1));
bool is_b_frame = false;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_b1, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_b1, is_b_frame));
EXPECT_TRUE(is_b_frame);
// Test that the function correctly processes NALU type 1 (the main case)
// NonIDR NALU (type 1) with P-frame slice_type=0
uint8_t data_p1[] = {0x01, 0x88, 0x00, 0x00}; // NALU type 1, slice_type=0 (P)
SrsSample sample_p1((char *)data_p1, sizeof(data_p1));
SrsNaluSample sample_p1((char *)data_p1, sizeof(data_p1));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_p1, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_p1, is_b_frame));
EXPECT_FALSE(is_b_frame);
// NonIDR NALU (type 1) with I-frame slice_type=2
uint8_t data_i1[] = {0x01, 0x98, 0x00, 0x00}; // NALU type 1, slice_type=2 (I)
SrsSample sample_i1((char *)data_i1, sizeof(data_i1));
SrsNaluSample sample_i1((char *)data_i1, sizeof(data_i1));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_i1, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_i1, is_b_frame));
EXPECT_FALSE(is_b_frame);
// DataPartitionA NALU (type 2) with B-frame slice_type=1
uint8_t data_dpa_b[] = {0x02, 0xA8, 0x00, 0x00}; // NALU type 2, slice_type=1 (B)
SrsSample sample_dpa_b((char *)data_dpa_b, sizeof(data_dpa_b));
SrsNaluSample sample_dpa_b((char *)data_dpa_b, sizeof(data_dpa_b));
is_b_frame = false;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_dpa_b, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_dpa_b, is_b_frame));
EXPECT_TRUE(is_b_frame);
// DataPartitionA NALU (type 2) with P-frame slice_type=0
uint8_t data_dpa_p[] = {0x02, 0x88, 0x00, 0x00}; // NALU type 2, slice_type=0 (P)
SrsSample sample_dpa_p((char *)data_dpa_p, sizeof(data_dpa_p));
SrsNaluSample sample_dpa_p((char *)data_dpa_p, sizeof(data_dpa_p));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_dpa_p, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_dpa_p, is_b_frame));
EXPECT_FALSE(is_b_frame);
// DataPartitionB NALU (type 3) with B-frame slice_type=1
uint8_t data_dpb_b[] = {0x03, 0xA8, 0x00, 0x00}; // NALU type 3, slice_type=1 (B)
SrsSample sample_dpb_b((char *)data_dpb_b, sizeof(data_dpb_b));
SrsNaluSample sample_dpb_b((char *)data_dpb_b, sizeof(data_dpb_b));
is_b_frame = false;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_dpb_b, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_dpb_b, is_b_frame));
EXPECT_TRUE(is_b_frame);
// DataPartitionC NALU (type 4) with B-frame slice_type=1
uint8_t data_dpc_b[] = {0x04, 0xA8, 0x00, 0x00}; // NALU type 4, slice_type=1 (B)
SrsSample sample_dpc_b((char *)data_dpc_b, sizeof(data_dpc_b));
SrsNaluSample sample_dpc_b((char *)data_dpc_b, sizeof(data_dpc_b));
is_b_frame = false;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_dpc_b, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_dpc_b, is_b_frame));
EXPECT_TRUE(is_b_frame);
}
}
@ -3709,93 +3715,93 @@ VOID TEST(KernelCodecTest, VideoFrameH264_BFrameDetection_ForbiddenNaluTypes)
// IDR NALU (type 5) - cannot contain B-frames by definition
uint8_t data_idr[] = {0x05, 0xA8, 0x00, 0x00}; // NALU type 5, any slice data
SrsSample sample_idr((char *)data_idr, sizeof(data_idr));
SrsNaluSample sample_idr((char *)data_idr, sizeof(data_idr));
bool is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_idr, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_idr, is_b_frame));
EXPECT_FALSE(is_b_frame);
// SEI NALU (type 6) - cannot contain B-frames
uint8_t data_sei[] = {0x06, 0xA8, 0x00, 0x00}; // NALU type 6
SrsSample sample_sei((char *)data_sei, sizeof(data_sei));
SrsNaluSample sample_sei((char *)data_sei, sizeof(data_sei));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_sei, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_sei, is_b_frame));
EXPECT_FALSE(is_b_frame);
// SPS NALU (type 7) - cannot contain B-frames
uint8_t data_sps[] = {0x07, 0xA8, 0x00, 0x00}; // NALU type 7
SrsSample sample_sps((char *)data_sps, sizeof(data_sps));
SrsNaluSample sample_sps((char *)data_sps, sizeof(data_sps));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_sps, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_sps, is_b_frame));
EXPECT_FALSE(is_b_frame);
// PPS NALU (type 8) - cannot contain B-frames
uint8_t data_pps[] = {0x08, 0xA8, 0x00, 0x00}; // NALU type 8
SrsSample sample_pps((char *)data_pps, sizeof(data_pps));
SrsNaluSample sample_pps((char *)data_pps, sizeof(data_pps));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_pps, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_pps, is_b_frame));
EXPECT_FALSE(is_b_frame);
// AUD NALU (type 9) - cannot contain B-frames
uint8_t data_aud[] = {0x09, 0xA8, 0x00, 0x00}; // NALU type 9
SrsSample sample_aud((char *)data_aud, sizeof(data_aud));
SrsNaluSample sample_aud((char *)data_aud, sizeof(data_aud));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_aud, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_aud, is_b_frame));
EXPECT_FALSE(is_b_frame);
// End of Sequence NALU (type 10) - cannot contain B-frames
uint8_t data_eos[] = {0x0A, 0xA8, 0x00, 0x00}; // NALU type 10
SrsSample sample_eos((char *)data_eos, sizeof(data_eos));
SrsNaluSample sample_eos((char *)data_eos, sizeof(data_eos));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_eos, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_eos, is_b_frame));
EXPECT_FALSE(is_b_frame);
// End of Stream NALU (type 11) - cannot contain B-frames
uint8_t data_eost[] = {0x0B, 0xA8, 0x00, 0x00}; // NALU type 11
SrsSample sample_eost((char *)data_eost, sizeof(data_eost));
SrsNaluSample sample_eost((char *)data_eost, sizeof(data_eost));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_eost, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_eost, is_b_frame));
EXPECT_FALSE(is_b_frame);
// Filler Data NALU (type 12) - cannot contain B-frames
uint8_t data_filler[] = {0x0C, 0xA8, 0x00, 0x00}; // NALU type 12
SrsSample sample_filler((char *)data_filler, sizeof(data_filler));
SrsNaluSample sample_filler((char *)data_filler, sizeof(data_filler));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_filler, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_filler, is_b_frame));
EXPECT_FALSE(is_b_frame);
// SPS Extension NALU (type 13) - cannot contain B-frames
uint8_t data_sps_ext[] = {0x0D, 0xA8, 0x00, 0x00}; // NALU type 13
SrsSample sample_sps_ext((char *)data_sps_ext, sizeof(data_sps_ext));
SrsNaluSample sample_sps_ext((char *)data_sps_ext, sizeof(data_sps_ext));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_sps_ext, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_sps_ext, is_b_frame));
EXPECT_FALSE(is_b_frame);
// Prefix NALU (type 14) - cannot contain B-frames
uint8_t data_prefix[] = {0x0E, 0xA8, 0x00, 0x00}; // NALU type 14
SrsSample sample_prefix((char *)data_prefix, sizeof(data_prefix));
SrsNaluSample sample_prefix((char *)data_prefix, sizeof(data_prefix));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_prefix, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_prefix, is_b_frame));
EXPECT_FALSE(is_b_frame);
// Subset SPS NALU (type 15) - cannot contain B-frames
uint8_t data_subset_sps[] = {0x0F, 0xA8, 0x00, 0x00}; // NALU type 15
SrsSample sample_subset_sps((char *)data_subset_sps, sizeof(data_subset_sps));
SrsNaluSample sample_subset_sps((char *)data_subset_sps, sizeof(data_subset_sps));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_subset_sps, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_subset_sps, is_b_frame));
EXPECT_FALSE(is_b_frame);
// Layer Without Partition NALU (type 19) - cannot contain B-frames
uint8_t data_layer[] = {0x13, 0xA8, 0x00, 0x00}; // NALU type 19
SrsSample sample_layer((char *)data_layer, sizeof(data_layer));
SrsNaluSample sample_layer((char *)data_layer, sizeof(data_layer));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_layer, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_layer, is_b_frame));
EXPECT_FALSE(is_b_frame);
// Coded Slice Extension NALU (type 20) - cannot contain B-frames
uint8_t data_slice_ext[] = {0x14, 0xA8, 0x00, 0x00}; // NALU type 20
SrsSample sample_slice_ext((char *)data_slice_ext, sizeof(data_slice_ext));
SrsNaluSample sample_slice_ext((char *)data_slice_ext, sizeof(data_slice_ext));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_slice_ext, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_slice_ext, is_b_frame));
EXPECT_FALSE(is_b_frame);
}
}
@ -3808,129 +3814,129 @@ VOID TEST(KernelCodecTest, VideoFrameH264_BFrameDetection_EdgeCases)
if (true) {
// IDR NALU (type 5) - cannot contain B-frames by definition
uint8_t data_idr[] = {0x05, 0xA8, 0x00, 0x00}; // NALU type 5, any slice data
SrsSample sample_idr((char *)data_idr, sizeof(data_idr));
SrsNaluSample sample_idr((char *)data_idr, sizeof(data_idr));
bool is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_idr, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_idr, is_b_frame));
EXPECT_FALSE(is_b_frame);
// SEI NALU (type 6) - cannot contain B-frames
uint8_t data_sei[] = {0x06, 0xA8, 0x00, 0x00}; // NALU type 6
SrsSample sample_sei((char *)data_sei, sizeof(data_sei));
SrsNaluSample sample_sei((char *)data_sei, sizeof(data_sei));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_sei, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_sei, is_b_frame));
EXPECT_FALSE(is_b_frame);
// SPS NALU (type 7) - cannot contain B-frames
uint8_t data_sps[] = {0x07, 0xA8, 0x00, 0x00}; // NALU type 7
SrsSample sample_sps((char *)data_sps, sizeof(data_sps));
SrsNaluSample sample_sps((char *)data_sps, sizeof(data_sps));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_sps, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_sps, is_b_frame));
EXPECT_FALSE(is_b_frame);
// PPS NALU (type 8) - cannot contain B-frames
uint8_t data_pps[] = {0x08, 0xA8, 0x00, 0x00}; // NALU type 8
SrsSample sample_pps((char *)data_pps, sizeof(data_pps));
SrsNaluSample sample_pps((char *)data_pps, sizeof(data_pps));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_pps, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_pps, is_b_frame));
EXPECT_FALSE(is_b_frame);
// AUD NALU (type 9) - cannot contain B-frames
uint8_t data_aud[] = {0x09, 0xA8, 0x00, 0x00}; // NALU type 9
SrsSample sample_aud((char *)data_aud, sizeof(data_aud));
SrsNaluSample sample_aud((char *)data_aud, sizeof(data_aud));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_aud, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_aud, is_b_frame));
EXPECT_FALSE(is_b_frame);
// End of Sequence NALU (type 10) - cannot contain B-frames
uint8_t data_eos[] = {0x0A, 0xA8, 0x00, 0x00}; // NALU type 10
SrsSample sample_eos((char *)data_eos, sizeof(data_eos));
SrsNaluSample sample_eos((char *)data_eos, sizeof(data_eos));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_eos, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_eos, is_b_frame));
EXPECT_FALSE(is_b_frame);
// End of Stream NALU (type 11) - cannot contain B-frames
uint8_t data_eost[] = {0x0B, 0xA8, 0x00, 0x00}; // NALU type 11
SrsSample sample_eost((char *)data_eost, sizeof(data_eost));
SrsNaluSample sample_eost((char *)data_eost, sizeof(data_eost));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_eost, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_eost, is_b_frame));
EXPECT_FALSE(is_b_frame);
// Filler Data NALU (type 12) - cannot contain B-frames
uint8_t data_filler[] = {0x0C, 0xA8, 0x00, 0x00}; // NALU type 12
SrsSample sample_filler((char *)data_filler, sizeof(data_filler));
SrsNaluSample sample_filler((char *)data_filler, sizeof(data_filler));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_filler, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_filler, is_b_frame));
EXPECT_FALSE(is_b_frame);
// SPS Extension NALU (type 13) - cannot contain B-frames
uint8_t data_sps_ext[] = {0x0D, 0xA8, 0x00, 0x00}; // NALU type 13
SrsSample sample_sps_ext((char *)data_sps_ext, sizeof(data_sps_ext));
SrsNaluSample sample_sps_ext((char *)data_sps_ext, sizeof(data_sps_ext));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_sps_ext, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_sps_ext, is_b_frame));
EXPECT_FALSE(is_b_frame);
// Prefix NALU (type 14) - cannot contain B-frames
uint8_t data_prefix[] = {0x0E, 0xA8, 0x00, 0x00}; // NALU type 14
SrsSample sample_prefix((char *)data_prefix, sizeof(data_prefix));
SrsNaluSample sample_prefix((char *)data_prefix, sizeof(data_prefix));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_prefix, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_prefix, is_b_frame));
EXPECT_FALSE(is_b_frame);
// Subset SPS NALU (type 15) - cannot contain B-frames
uint8_t data_subset_sps[] = {0x0F, 0xA8, 0x00, 0x00}; // NALU type 15
SrsSample sample_subset_sps((char *)data_subset_sps, sizeof(data_subset_sps));
SrsNaluSample sample_subset_sps((char *)data_subset_sps, sizeof(data_subset_sps));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_subset_sps, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_subset_sps, is_b_frame));
EXPECT_FALSE(is_b_frame);
// Layer Without Partition NALU (type 19) - cannot contain B-frames
uint8_t data_layer[] = {0x13, 0xA8, 0x00, 0x00}; // NALU type 19
SrsSample sample_layer((char *)data_layer, sizeof(data_layer));
SrsNaluSample sample_layer((char *)data_layer, sizeof(data_layer));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_layer, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_layer, is_b_frame));
EXPECT_FALSE(is_b_frame);
// Coded Slice Extension NALU (type 20) - cannot contain B-frames
uint8_t data_slice_ext[] = {0x14, 0xA8, 0x00, 0x00}; // NALU type 20
SrsSample sample_slice_ext((char *)data_slice_ext, sizeof(data_slice_ext));
SrsNaluSample sample_slice_ext((char *)data_slice_ext, sizeof(data_slice_ext));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_slice_ext, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_slice_ext, is_b_frame));
EXPECT_FALSE(is_b_frame);
}
// Test edge cases and error conditions
if (true) {
// Empty Sample - should fail
SrsSample empty_sample(NULL, 0);
SrsNaluSample empty_sample(NULL, 0);
bool is_b_frame = false;
HELPER_EXPECT_FAILED(SrsVideoFrame::parse_avc_bframe(&empty_sample, is_b_frame));
HELPER_EXPECT_FAILED(SrsParsedVideoPacket::parse_avc_bframe(&empty_sample, is_b_frame));
// Sample too small for slice parsing (only NALU header) - should fail for slice types
uint8_t data_small[] = {0x01}; // NALU type 1, but no slice data
SrsSample sample_small((char *)data_small, sizeof(data_small));
SrsNaluSample sample_small((char *)data_small, sizeof(data_small));
is_b_frame = false;
HELPER_EXPECT_FAILED(SrsVideoFrame::parse_avc_bframe(&sample_small, is_b_frame));
HELPER_EXPECT_FAILED(SrsParsedVideoPacket::parse_avc_bframe(&sample_small, is_b_frame));
// Test basic slice types for NonIDR NALU using known working patterns
// P frame (slice_type=0)
uint8_t data_p[] = {0x01, 0x88, 0x00, 0x00}; // slice_type=0
SrsSample sample_p((char *)data_p, sizeof(data_p));
SrsNaluSample sample_p((char *)data_p, sizeof(data_p));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_p, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_p, is_b_frame));
EXPECT_FALSE(is_b_frame);
// B frame (slice_type=1)
uint8_t data_b[] = {0x01, 0xA8, 0x00, 0x00}; // slice_type=1
SrsSample sample_b((char *)data_b, sizeof(data_b));
SrsNaluSample sample_b((char *)data_b, sizeof(data_b));
is_b_frame = false;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_b, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_b, is_b_frame));
EXPECT_TRUE(is_b_frame);
// I frame (slice_type=2)
uint8_t data_i[] = {0x01, 0x98, 0x00, 0x00}; // slice_type=2
SrsSample sample_i((char *)data_i, sizeof(data_i));
SrsNaluSample sample_i((char *)data_i, sizeof(data_i));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_avc_bframe(&sample_i, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_avc_bframe(&sample_i, is_b_frame));
EXPECT_FALSE(is_b_frame);
}
}
@ -3942,47 +3948,47 @@ VOID TEST(KernelCodecTest, VideoFrameH265)
if (true) {
// I Frame
uint8_t data[] = {0x26, 0x01, 0x00, 0x00};
SrsSample sample((char *)data, sizeof(data));
SrsNaluSample sample((char *)data, sizeof(data));
SrsHevcNaluType nalu_type = SrsHevcNaluType_INVALID;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_hevc_nalu_type(&sample, nalu_type));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_hevc_nalu_type(&sample, nalu_type));
EXPECT_EQ(nalu_type, SrsHevcNaluType_CODED_SLICE_IDR);
// P Frame
uint8_t data2[] = {0x02, 0x01, 0x00, 0x00};
SrsSample sample2((char *)data2, sizeof(data2));
SrsNaluSample sample2((char *)data2, sizeof(data2));
nalu_type = SrsHevcNaluType_INVALID;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_hevc_nalu_type(&sample2, nalu_type));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_hevc_nalu_type(&sample2, nalu_type));
EXPECT_EQ(nalu_type, SrsHevcNaluType_CODED_SLICE_TRAIL_R);
// VPS
uint8_t data3[] = {0x40, 0x01, 0x00, 0x00};
SrsSample sample3((char *)data3, sizeof(data3));
SrsNaluSample sample3((char *)data3, sizeof(data3));
nalu_type = SrsHevcNaluType_INVALID;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_hevc_nalu_type(&sample3, nalu_type));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_hevc_nalu_type(&sample3, nalu_type));
EXPECT_EQ(nalu_type, SrsHevcNaluType_VPS);
// SPS
uint8_t data4[] = {0x42, 0x01, 0x00, 0x00};
SrsSample sample4((char *)data4, sizeof(data4));
SrsNaluSample sample4((char *)data4, sizeof(data4));
nalu_type = SrsHevcNaluType_INVALID;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_hevc_nalu_type(&sample4, nalu_type));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_hevc_nalu_type(&sample4, nalu_type));
EXPECT_EQ(nalu_type, SrsHevcNaluType_SPS);
// PPS
uint8_t data5[] = {0x44, 0x01, 0x00, 0x00};
SrsSample sample5((char *)data5, sizeof(data5));
SrsNaluSample sample5((char *)data5, sizeof(data5));
nalu_type = SrsHevcNaluType_INVALID;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_hevc_nalu_type(&sample5, nalu_type));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_hevc_nalu_type(&sample5, nalu_type));
EXPECT_EQ(nalu_type, SrsHevcNaluType_PPS);
// Empty Sample
SrsSample empty_sample(NULL, 0);
HELPER_EXPECT_FAILED(SrsVideoFrame::parse_hevc_nalu_type(&empty_sample, nalu_type));
SrsNaluSample empty_sample(NULL, 0);
HELPER_EXPECT_FAILED(SrsParsedVideoPacket::parse_hevc_nalu_type(&empty_sample, nalu_type));
}
if (true) {
@ -3991,55 +3997,55 @@ VOID TEST(KernelCodecTest, VideoFrameH265)
// B Frame, slice_type=0(B Frame)
uint8_t data[] = {0x02, 0x01, 0xE0, 0x44};
SrsSample sample((char *)data, sizeof(data));
SrsNaluSample sample((char *)data, sizeof(data));
bool is_b_frame = false;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_hevc_bframe(&sample, &format, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_hevc_bframe(&sample, &format, is_b_frame));
EXPECT_TRUE(is_b_frame);
// Non-B Frame, slice_type=1(P Frame)
uint8_t data2[] = {0x02, 0x01, 0xD0, 0x30};
SrsSample sample2((char *)data2, sizeof(data2));
SrsNaluSample sample2((char *)data2, sizeof(data2));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_hevc_bframe(&sample2, &format, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_hevc_bframe(&sample2, &format, is_b_frame));
EXPECT_FALSE(is_b_frame);
// VPS
uint8_t data3[] = {0x40, 0x01, 0xE0, 0x44};
SrsSample sample3((char *)data3, sizeof(data3));
SrsNaluSample sample3((char *)data3, sizeof(data3));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_hevc_bframe(&sample3, &format, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_hevc_bframe(&sample3, &format, is_b_frame));
EXPECT_FALSE(is_b_frame);
// SPS
uint8_t data4[] = {0x42, 0x01, 0xE0, 0x44};
SrsSample sample4((char *)data4, sizeof(data4));
SrsNaluSample sample4((char *)data4, sizeof(data4));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_hevc_bframe(&sample4, &format, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_hevc_bframe(&sample4, &format, is_b_frame));
EXPECT_FALSE(is_b_frame);
// PPS
uint8_t data5[] = {0x44, 0x01, 0xE0, 0x44};
SrsSample sample5((char *)data5, sizeof(data5));
SrsNaluSample sample5((char *)data5, sizeof(data5));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_hevc_bframe(&sample5, &format, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_hevc_bframe(&sample5, &format, is_b_frame));
EXPECT_FALSE(is_b_frame);
// IDR
uint8_t data6[] = {0x26, 0x01, 0xE0, 0x44};
SrsSample sample6((char *)data6, sizeof(data6));
SrsNaluSample sample6((char *)data6, sizeof(data6));
is_b_frame = true;
HELPER_EXPECT_SUCCESS(SrsVideoFrame::parse_hevc_bframe(&sample6, &format, is_b_frame));
HELPER_EXPECT_SUCCESS(SrsParsedVideoPacket::parse_hevc_bframe(&sample6, &format, is_b_frame));
EXPECT_FALSE(is_b_frame);
// Empty Sample
SrsSample empty_sample(NULL, 0);
HELPER_EXPECT_FAILED(SrsVideoFrame::parse_hevc_bframe(&empty_sample, &format, is_b_frame));
SrsNaluSample empty_sample(NULL, 0);
HELPER_EXPECT_FAILED(SrsParsedVideoPacket::parse_hevc_bframe(&empty_sample, &format, is_b_frame));
}
}
@ -4050,7 +4056,7 @@ VOID TEST(KernelCodecTest, IsSequenceHeaderSpecial)
EXPECT_FALSE(f.is_avc_sequence_header());
f.vcodec = new SrsVideoCodecConfig();
f.video = new SrsVideoFrame();
f.video = new SrsParsedVideoPacket();
EXPECT_FALSE(f.is_avc_sequence_header());
f.vcodec->id = SrsVideoCodecIdAVC;
@ -4065,7 +4071,7 @@ VOID TEST(KernelCodecTest, IsSequenceHeaderSpecial)
EXPECT_FALSE(f.is_avc_sequence_header());
f.vcodec = new SrsVideoCodecConfig();
f.video = new SrsVideoFrame();
f.video = new SrsParsedVideoPacket();
EXPECT_FALSE(f.is_avc_sequence_header());
f.vcodec->id = SrsVideoCodecIdHEVC;
@ -5289,8 +5295,8 @@ VOID TEST(KernelFLVTest, CoverAll)
EXPECT_EQ(30, m.header.timestamp_delta);
EXPECT_EQ(30, m.header.timestamp);
SrsSharedPtrMessage s;
HELPER_EXPECT_SUCCESS(s.create(&m));
SrsMediaPacket s;
m.to_msg(&s);
EXPECT_TRUE(s.is_av());
EXPECT_TRUE(!s.is_audio());
EXPECT_TRUE(s.is_video());
@ -5304,10 +5310,12 @@ VOID TEST(KernelFLVTest, CoverAll)
SrsMessageHeader h;
h.initialize_video(10, 30, 20);
SrsSharedPtrMessage m;
HELPER_EXPECT_SUCCESS(m.create(&h, new char[1], 1));
SrsMediaPacket m;
SrsCommonMessage common_msg;
HELPER_EXPECT_SUCCESS(common_msg.create(&h, new char[1], 1));
common_msg.to_msg(&m);
SrsSharedPtrMessage *msgs = &m;
SrsMediaPacket *msgs = &m;
HELPER_EXPECT_SUCCESS(mux.write_tags(&msgs, 1));
EXPECT_EQ(16, f.tellg());
@ -5320,28 +5328,34 @@ VOID TEST(KernelFLVTest, CoverSharedPtrMessage)
if (true) {
SrsMessageHeader h;
SrsSharedPtrMessage m;
HELPER_EXPECT_SUCCESS(m.create(&h, new char[1], 1));
SrsMediaPacket m;
SrsCommonMessage common_msg;
HELPER_EXPECT_SUCCESS(common_msg.create(&h, new char[1], 1));
common_msg.to_msg(&m);
}
if (true) {
SrsMessageHeader h;
SrsSharedPtrMessage m;
HELPER_EXPECT_SUCCESS(m.create(&h, NULL, 0));
SrsMediaPacket m;
SrsCommonMessage common_msg;
HELPER_EXPECT_SUCCESS(common_msg.create(&h, NULL, 0));
common_msg.to_msg(&m);
}
if (true) {
SrsMessageHeader h;
SrsSharedPtrMessage m;
HELPER_EXPECT_FAILED(m.create(&h, NULL, -1));
SrsMediaPacket m;
SrsCommonMessage common_msg;
HELPER_EXPECT_FAILED(common_msg.create(&h, NULL, -1));
}
if (true) {
SrsMessageHeader h;
h.prefer_cid = 1;
SrsSharedPtrMessage m;
HELPER_EXPECT_SUCCESS(m.create(&h, NULL, 0));
SrsMediaPacket m;
SrsCommonMessage common_msg;
HELPER_EXPECT_SUCCESS(common_msg.create(&h, NULL, 0));
common_msg.to_msg(&m);
EXPECT_FALSE(m.check(1));
EXPECT_TRUE(m.check(1));

88
trunk/src/utest/srs_utest_protocol.cpp
View File

@ -896,9 +896,11 @@ VOID TEST(ProtocolMsgArrayTest, MessageArray)
srs_error_t err = srs_success;
SrsMessageHeader header;
SrsSharedPtrMessage msg;
SrsMediaPacket msg;
char *payload = new char[1024];
HELPER_EXPECT_SUCCESS(msg.create(&header, payload, 1024));
SrsCommonMessage common_msg;
HELPER_EXPECT_SUCCESS(common_msg.create(&header, payload, 1024));
common_msg.to_msg(&msg);
if (true) {
SrsMessageArray arr(3);
@ -1012,9 +1014,9 @@ VOID TEST(ProtocolStackTest, ProtocolRecvMessage)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt = NULL;
SrsRtmpCommand *pkt = NULL;
HELPER_EXPECT_SUCCESS(proto.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
SrsConnectAppPacket *spkt = dynamic_cast<SrsConnectAppPacket *>(pkt);
ASSERT_TRUE(NULL != spkt);
@ -1049,9 +1051,9 @@ VOID TEST(ProtocolStackTest, ProtocolRecvMessageBug98)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt = NULL;
SrsRtmpCommand *pkt = NULL;
HELPER_EXPECT_SUCCESS(proto.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
SrsUserControlPacket *spkt = dynamic_cast<SrsUserControlPacket *>(pkt);
ASSERT_TRUE(NULL != spkt);
@ -1085,9 +1087,9 @@ VOID TEST(ProtocolStackTest, ProtocolRecvAckSizeMessage)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt = NULL;
SrsRtmpCommand *pkt = NULL;
HELPER_EXPECT_SUCCESS(proto.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
SrsSetWindowAckSizePacket *spkt = dynamic_cast<SrsSetWindowAckSizePacket *>(pkt);
ASSERT_TRUE(NULL != spkt);
@ -3765,8 +3767,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid1BNormal)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
EXPECT_TRUE(msg->header.is_video());
// 1B cid(6bits), cid in 2-63
EXPECT_EQ(0x09, msg->header.prefer_cid);
}
/**
@ -3817,8 +3817,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid1BMax)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
EXPECT_TRUE(msg->header.is_video());
// 1B cid(6bits), max is 63
EXPECT_EQ(0x3F, msg->header.prefer_cid);
}
/**
@ -3869,8 +3867,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid2BMin)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
EXPECT_TRUE(msg->header.is_video());
// 2B cid(8bits), min is 64
EXPECT_EQ(64, msg->header.prefer_cid);
}
/**
@ -3921,8 +3917,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid2BNormal)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
EXPECT_TRUE(msg->header.is_video());
// 2B cid(8bits), cid in 64-319
EXPECT_EQ(0x10 + 64, msg->header.prefer_cid);
}
/**
@ -3973,8 +3967,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid2BNormal2)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
EXPECT_TRUE(msg->header.is_video());
// 2B cid(8bits), cid in 64-319
EXPECT_EQ(0x11 + 64, msg->header.prefer_cid);
}
/**
@ -4025,8 +4017,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid2BMax)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
EXPECT_TRUE(msg->header.is_video());
// 2B cid(68bits), max is 319
EXPECT_EQ(319, msg->header.prefer_cid);
}
/**
@ -4077,8 +4067,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid3BMin)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
EXPECT_TRUE(msg->header.is_video());
// 3B cid(16bits), min is 64
EXPECT_EQ(64, msg->header.prefer_cid);
}
/**
@ -4129,8 +4117,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid3BNormal)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
EXPECT_TRUE(msg->header.is_video());
// 3B cid(16bits), cid in 64-65599
EXPECT_EQ(0x10 * 256 + 64, msg->header.prefer_cid);
}
/**
@ -4181,8 +4167,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid3BNormal2)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
EXPECT_TRUE(msg->header.is_video());
// 3B cid(16bits), cid in 64-65599
EXPECT_EQ(0x01 + (0x10 * 256) + 64, msg->header.prefer_cid);
}
/**
@ -4233,8 +4217,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid3BNormal3)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
EXPECT_TRUE(msg->header.is_video());
// 3B cid(16bits), cid in 64-65599
EXPECT_EQ(0xFF + (0x10 * 256) + 64, msg->header.prefer_cid);
}
/**
@ -4285,8 +4267,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid3BNormal4)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
EXPECT_TRUE(msg->header.is_video());
// 3B cid(16bits), cid in 64-65599
EXPECT_EQ(0x02 + (0x10 * 256) + 64, msg->header.prefer_cid);
}
/**
@ -4337,8 +4317,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid3BMax)
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
EXPECT_TRUE(msg->header.is_video());
// 2B cid(16bits), max is 65599
EXPECT_EQ(65599, msg->header.prefer_cid);
}
/**
@ -4397,8 +4375,8 @@ VOID TEST(ProtocolStackTest, ProtocolSendVMessage)
msg->create_payload(sizeof(data));
memcpy(msg->payload(), data, sizeof(data));
SrsSharedPtrMessage m;
HELPER_ASSERT_SUCCESS(m.create(msg));
SrsMediaPacket m;
msg->to_msg(&m);
HELPER_EXPECT_SUCCESS(proto.send_and_free_message(m.copy(), 0));
EXPECT_EQ(16, bio.out_buffer.length());
@ -4427,7 +4405,7 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsCallPacket)
HELPER_EXPECT_SUCCESS(proto.send_and_free_packet(pkt, 0));
char buf[] = {
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x14,
0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x14,
0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x07, 0x6d,
0x79, 0x5f, 0x63, 0x61, 0x6c, 0x6c, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
@ -4470,7 +4448,7 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsCallResPacket)
HELPER_EXPECT_SUCCESS(proto.send_and_free_packet(pkt, 0));
char buf[] = {
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x14,
0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x14,
0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x07, 0x5f,
0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
@ -4505,7 +4483,7 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsCreateStreamPacket)
HELPER_EXPECT_SUCCESS(proto.send_and_free_packet(pkt, 0));
char buf[] = {
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x14,
0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x14,
0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0c, 0x63,
0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x74, 0x72,
0x65, 0x61, 0x6d, 0x00, 0x40, 0x00, 0x00, 0x00,
@ -4530,7 +4508,7 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsFMLEStartPacket)
HELPER_EXPECT_SUCCESS(proto.send_and_free_packet(pkt, 0));
char buf[] = {
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x14,
0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x14,
0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x09, 0x46,
0x4d, 0x4c, 0x45, 0x53, 0x74, 0x61, 0x72, 0x74,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -4561,7 +4539,7 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsFMLEStartResPacket)
HELPER_EXPECT_SUCCESS(proto.send_and_free_packet(pkt, 0));
uint8_t buf[] = {
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x14,
0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x14,
0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x09, 0x46,
0x4d, 0x4c, 0x45, 0x53, 0x74, 0x61, 0x72, 0x74,
0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -4648,7 +4626,7 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsOnBWDonePacket)
HELPER_EXPECT_SUCCESS(proto.send_and_free_packet(pkt, 0));
char buf[] = {
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x14,
0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x14,
0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x08, 0x6f,
0x6e, 0x42, 0x57, 0x44, 0x6f, 0x6e, 0x65, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -4724,16 +4702,16 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsOnStatusDataPacket)
}
/**
* send a SrsSampleAccessPacket packet
* send a SrsNaluSampleAccessPacket packet
*/
VOID TEST(ProtocolStackTest, ProtocolSendSrsSampleAccessPacket)
VOID TEST(ProtocolStackTest, ProtocolSendSrsNaluSampleAccessPacket)
{
srs_error_t err = srs_success;
MockBufferIO bio;
SrsProtocol proto(&bio);
SrsSampleAccessPacket *pkt = new SrsSampleAccessPacket();
SrsNaluSampleAccessPacket *pkt = new SrsNaluSampleAccessPacket();
pkt->command_name = "|RtmpSampleAccess";
pkt->video_sample_access = true;
pkt->audio_sample_access = true;
@ -4769,7 +4747,7 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsOnMetaDataPacket)
HELPER_EXPECT_SUCCESS(proto.send_and_free_packet(pkt, 0));
uint8_t buf[] = {
0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x12,
0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x12,
0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0a, 0x6f,
0x6e, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74,
0x61, 0x03, 0x00, 0x05, 0x77, 0x69, 0x64, 0x74,
@ -4795,7 +4773,7 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsSetWindowAckSizePacket)
HELPER_EXPECT_SUCCESS(proto.send_and_free_packet(pkt, 0));
uint8_t buf[] = {
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05,
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x90, 0x00};
EXPECT_TRUE(srs_bytes_equal(bio.out_buffer.bytes(), (char *)buf, sizeof(buf)));
}
@ -4815,7 +4793,7 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsAcknowledgementPacket)
HELPER_EXPECT_SUCCESS(proto.send_and_free_packet(pkt, 0));
char buf[] = {
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x03,
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x03,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00};
EXPECT_TRUE(srs_bytes_equal(bio.out_buffer.bytes(), buf, sizeof(buf)));
}
@ -4835,7 +4813,7 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsSetChunkSizePacket)
HELPER_EXPECT_SUCCESS(proto.send_and_free_packet(pkt, 0));
char buf[] = {
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01,
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00};
EXPECT_TRUE(srs_bytes_equal(bio.out_buffer.bytes(), buf, sizeof(buf)));
}
@ -4856,7 +4834,7 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsSetPeerBandwidthPacket)
HELPER_EXPECT_SUCCESS(proto.send_and_free_packet(pkt, 0));
char buf[] = {
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x06,
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x06,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x01};
EXPECT_TRUE(srs_bytes_equal(bio.out_buffer.bytes(), buf, sizeof(buf)));
@ -4879,7 +4857,7 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsUserControlPacket)
HELPER_EXPECT_SUCCESS(proto.send_and_free_packet(pkt, 0));
char buf[] = {
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x04,
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x04,
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00, 0x00, 0x10};
@ -4961,8 +4939,8 @@ VOID TEST(ProtocolStackTest, ProtocolAckSizeFlow)
msg->header.message_type = 9;
EXPECT_TRUE(msg->header.is_video());
SrsSharedPtrMessage m;
HELPER_ASSERT_SUCCESS(m.create(msg));
SrsMediaPacket m;
msg->to_msg(&m);
HELPER_EXPECT_SUCCESS(proto.send_and_free_message(m.copy(), 1));
}
@ -5011,8 +4989,8 @@ VOID TEST(ProtocolStackTest, ProtocolAckSizeFlow)
msg->header.message_type = 9;
EXPECT_TRUE(msg->header.is_video());
SrsSharedPtrMessage m;
HELPER_ASSERT_SUCCESS(m.create(msg));
SrsMediaPacket m;
msg->to_msg(&m);
HELPER_EXPECT_SUCCESS(proto.send_and_free_message(m.copy(), 1));
}
@ -5086,9 +5064,9 @@ VOID TEST(ProtocolStackTest, ProtocolPingFlow)
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
ASSERT_TRUE(msg->header.is_user_control_message());
SrsPacket *pkt = NULL;
SrsRtmpCommand *pkt = NULL;
HELPER_ASSERT_SUCCESS(proto.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
SrsUserControlPacket *spkt = dynamic_cast<SrsUserControlPacket *>(pkt);
ASSERT_TRUE(spkt != NULL);

2
trunk/src/utest/srs_utest_protocol2.cpp
View File

@ -4269,8 +4269,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid1BMin)
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
EXPECT_TRUE(msg->header.is_video());
// 1B cid(6bits), min is 2
EXPECT_EQ(0x02, msg->header.prefer_cid);
}
VOID TEST(ProtocolKbpsTest, Connections)

24
trunk/src/utest/srs_utest_rtc.cpp
View File

@ -2344,21 +2344,21 @@ VOID TEST(KernelRTCTest, H265RtpSTAPPayload)
SrsRtpSTAPPayloadHevc stap;
// Create sample VPS NALU
SrsSample *vps = new SrsSample();
SrsNaluSample *vps = new SrsNaluSample();
uint8_t vps_data[] = {0x40, 0x01, 0x0c, 0x01, 0xff, 0xff, 0x01, 0x60, 0x00, 0x00, 0x03, 0x00, 0x90, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00, 0x3d, 0x95, 0x98, 0x09};
vps->bytes = (char *)vps_data;
vps->size = sizeof(vps_data);
stap.nalus.push_back(vps);
// Create sample SPS NALU
SrsSample *sps = new SrsSample();
SrsNaluSample *sps = new SrsNaluSample();
uint8_t sps_data[] = {0x42, 0x01, 0x01, 0x01, 0x60, 0x00, 0x00, 0x03, 0x00, 0x90, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00, 0x3d, 0xa0, 0x02, 0x80, 0x80, 0x2d, 0x16, 0x59, 0x59, 0xa4, 0x93, 0x2b, 0xc0, 0x5a, 0x70, 0x80, 0x80, 0x80, 0x82};
sps->bytes = (char *)sps_data;
sps->size = sizeof(sps_data);
stap.nalus.push_back(sps);
// Create sample PPS NALU
SrsSample *pps = new SrsSample();
SrsNaluSample *pps = new SrsNaluSample();
uint8_t pps_data[] = {0x44, 0x01, 0xc1, 0x72, 0xb4, 0x62, 0x40};
pps->bytes = (char *)pps_data;
pps->size = sizeof(pps_data);
@ -2383,17 +2383,17 @@ VOID TEST(KernelRTCTest, H265RtpSTAPPayload)
EXPECT_EQ(3, (int)decode_stap.nalus.size());
// Check VPS
SrsSample *decoded_vps = decode_stap.get_vps();
SrsNaluSample *decoded_vps = decode_stap.get_vps();
EXPECT_TRUE(decoded_vps != NULL);
EXPECT_EQ(sizeof(vps_data), (size_t)decoded_vps->size);
// Check SPS
SrsSample *decoded_sps = decode_stap.get_sps();
SrsNaluSample *decoded_sps = decode_stap.get_sps();
EXPECT_TRUE(decoded_sps != NULL);
EXPECT_EQ(sizeof(sps_data), (size_t)decoded_sps->size);
// Check PPS
SrsSample *decoded_pps = decode_stap.get_pps();
SrsNaluSample *decoded_pps = decode_stap.get_pps();
EXPECT_TRUE(decoded_pps != NULL);
EXPECT_EQ(sizeof(pps_data), (size_t)decoded_pps->size);
@ -2443,7 +2443,7 @@ VOID TEST(KernelRTCTest, H265RtpFUAPayload)
fua.nalu_type = SrsHevcNaluType_CODED_SLICE_IDR;
// Create sample payload data
SrsSample *sample = new SrsSample();
SrsNaluSample *sample = new SrsNaluSample();
uint8_t payload_data[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
sample->bytes = (char *)payload_data;
sample->size = sizeof(payload_data);
@ -2576,7 +2576,7 @@ VOID TEST(KernelRTCTest, H265RtpPacketKeyframe)
pkt.set_payload(stap_payload, SrsRtpPacketPayloadTypeSTAPHevc);
// Create VPS NALU
SrsSample *vps = new SrsSample();
SrsNaluSample *vps = new SrsNaluSample();
uint8_t vps_data[] = {0x40, 0x01}; // VPS NALU header
vps->bytes = (char *)vps_data;
vps->size = sizeof(vps_data);
@ -2624,7 +2624,7 @@ VOID TEST(KernelRTCTest, H265RtpRawNALUsSkipBytes)
SrsRtpRawNALUs raw_nalus;
// Create sample HEVC NALU
SrsSample *sample = new SrsSample();
SrsNaluSample *sample = new SrsNaluSample();
uint8_t nalu_data[] = {0x26, 0x01, 0x12, 0x34, 0x56, 0x78}; // IDR slice
sample->bytes = (char *)nalu_data;
sample->size = sizeof(nalu_data);
@ -2635,7 +2635,7 @@ VOID TEST(KernelRTCTest, H265RtpRawNALUsSkipBytes)
EXPECT_EQ(0x26, header); // Should return first byte
// Verify remaining data
std::vector<SrsSample *> samples;
std::vector<SrsNaluSample *> samples;
HELPER_EXPECT_SUCCESS(raw_nalus.read_samples(samples, 4));
EXPECT_EQ(1, (int)samples.size());
EXPECT_EQ(4, samples[0]->size);
@ -2655,7 +2655,7 @@ VOID TEST(KernelRTCTest, H265RtpRawNALUsSkipBytes)
SrsRtpRawNALUs raw_nalus;
// Create sample H.264 NALU
SrsSample *sample = new SrsSample();
SrsNaluSample *sample = new SrsNaluSample();
uint8_t nalu_data[] = {0x65, 0x12, 0x34, 0x56}; // IDR slice
sample->bytes = (char *)nalu_data;
sample->size = sizeof(nalu_data);
@ -2666,7 +2666,7 @@ VOID TEST(KernelRTCTest, H265RtpRawNALUsSkipBytes)
EXPECT_EQ(0x65, header); // Should return first byte
// Verify remaining data
std::vector<SrsSample *> samples;
std::vector<SrsNaluSample *> samples;
HELPER_EXPECT_SUCCESS(raw_nalus.read_samples(samples, 3));
EXPECT_EQ(1, (int)samples.size());
EXPECT_EQ(3, samples[0]->size);

2
trunk/src/utest/srs_utest_rtc2.cpp
View File

@ -1543,7 +1543,7 @@ public:
return srs_success;
}
virtual srs_error_t on_frame(SrsSharedPtrMessage *frame)
virtual srs_error_t on_frame(SrsMediaPacket *frame)
{
frame_count++;
return srs_success;

185
trunk/src/utest/srs_utest_rtmp.cpp
View File

@ -22,7 +22,7 @@
using namespace std;
class MockPacket : public SrsPacket
class MockPacket : public SrsRtmpCommand
{
public:
int size;
@ -89,8 +89,7 @@ VOID TEST(ProtocolRTMPTest, PacketEncode)
}
if (true) {
SrsPacket pkt;
EXPECT_EQ(0, pkt.get_prefer_cid());
SrsRtmpCommand pkt;
EXPECT_EQ(0, pkt.get_message_type());
EXPECT_EQ(0, pkt.get_size());
}
@ -230,7 +229,7 @@ VOID TEST(ProtocolRTMPTest, SendPacketsError)
MockBufferIO io;
SrsProtocol p(&io);
SrsPacket *pkt = new SrsPacket();
SrsRtmpCommand *pkt = new SrsRtmpCommand();
HELPER_EXPECT_SUCCESS(p.send_and_free_packet(pkt, 1));
}
@ -251,11 +250,11 @@ VOID TEST(ProtocolRTMPTest, SendPacketsError)
pkt.header.initialize_audio(200, 1000, 1);
pkt.create_payload(256);
SrsSharedPtrMessage *msg = new SrsSharedPtrMessage();
msg->create(&pkt);
SrsUniquePtr<SrsSharedPtrMessage> msg_uptr(msg);
SrsMediaPacket *msg = new SrsMediaPacket();
pkt.to_msg(msg);
SrsUniquePtr<SrsMediaPacket> msg_uptr(msg);
SrsSharedPtrMessage *msgs[10240];
SrsMediaPacket *msgs[10240];
for (int i = 0; i < 10240; i++) {
msgs[i] = msg->copy();
}
@ -320,16 +319,16 @@ VOID TEST(ProtocolRTMPTest, SendZeroMessages)
if (true) {
MockBufferIO io;
SrsProtocol p(&io);
SrsSharedPtrMessage *msg = new SrsSharedPtrMessage();
SrsMediaPacket *msg = new SrsMediaPacket();
HELPER_EXPECT_SUCCESS(p.send_and_free_message(msg, 1));
}
if (true) {
MockBufferIO io;
SrsProtocol p(&io);
SrsSharedPtrMessage *msgs[1024];
SrsMediaPacket *msgs[1024];
for (int i = 0; i < 1024; i++) {
msgs[i] = new SrsSharedPtrMessage();
msgs[i] = new SrsMediaPacket();
}
HELPER_EXPECT_SUCCESS(p.send_and_free_messages(msgs, 1024, 0));
}
@ -346,8 +345,8 @@ VOID TEST(ProtocolRTMPTest, HugeMessages)
pkt.header.initialize_audio(200, 1000, 1);
pkt.create_payload(256);
SrsSharedPtrMessage *msg = new SrsSharedPtrMessage();
msg->create(&pkt);
SrsMediaPacket *msg = new SrsMediaPacket();
pkt.to_msg(msg);
HELPER_EXPECT_SUCCESS(p.send_and_free_message(msg, 1));
EXPECT_EQ(269, io.out_buffer.length());
@ -361,11 +360,11 @@ VOID TEST(ProtocolRTMPTest, HugeMessages)
pkt.header.initialize_audio(200, 1000, 1);
pkt.create_payload(256);
SrsSharedPtrMessage *msg = new SrsSharedPtrMessage();
msg->create(&pkt);
SrsUniquePtr<SrsSharedPtrMessage> msg_uptr(msg);
SrsMediaPacket *msg = new SrsMediaPacket();
pkt.to_msg(msg);
SrsUniquePtr<SrsMediaPacket> msg_uptr(msg);
SrsSharedPtrMessage *msgs[1024];
SrsMediaPacket *msgs[1024];
for (int i = 0; i < 1024; i++) {
msgs[i] = msg->copy();
}
@ -382,11 +381,11 @@ VOID TEST(ProtocolRTMPTest, HugeMessages)
pkt.header.initialize_audio(200, 1000, 1);
pkt.create_payload(256);
SrsSharedPtrMessage *msg = new SrsSharedPtrMessage();
msg->create(&pkt);
SrsUniquePtr<SrsSharedPtrMessage> msg_uptr(msg);
SrsMediaPacket *msg = new SrsMediaPacket();
pkt.to_msg(msg);
SrsUniquePtr<SrsMediaPacket> msg_uptr(msg);
SrsSharedPtrMessage *msgs[10240];
SrsMediaPacket *msgs[10240];
for (int i = 0; i < 10240; i++) {
msgs[i] = msg->copy();
}
@ -409,7 +408,7 @@ VOID TEST(ProtocolRTMPTest, DecodeMessages)
msg.header.initialize_amf0_script(1, 1);
msg.create_payload(1);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
HELPER_EXPECT_FAILED(p.decode_message(&msg, &pkt));
}
}
@ -467,9 +466,9 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages2)
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
msg->header.message_type = RTMP_MSG_AMF3CommandMessage;
SrsPacket *pkt;
SrsRtmpCommand *pkt;
HELPER_EXPECT_SUCCESS(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
SrsCallPacket *call = (SrsCallPacket *)pkt;
EXPECT_STREQ("s", call->command_name.c_str());
@ -484,9 +483,9 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages2)
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
msg->header.message_type = RTMP_MSG_AMF3CommandMessage;
SrsPacket *pkt;
SrsRtmpCommand *pkt;
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -498,9 +497,9 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages2)
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
msg->header.message_type = 0xff;
SrsPacket *pkt;
SrsRtmpCommand *pkt;
HELPER_EXPECT_SUCCESS(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -512,9 +511,9 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages2)
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
msg->header.message_type = RTMP_MSG_AMF0DataMessage;
SrsPacket *pkt;
SrsRtmpCommand *pkt;
HELPER_EXPECT_SUCCESS(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
}
@ -531,10 +530,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages3)
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
msg->header.message_type = RTMP_MSG_AMF0DataMessage;
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Decode the response failed, no transaction ID was set by request.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -546,10 +545,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages3)
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
msg->header.message_type = RTMP_MSG_AMF3DataMessage;
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Decode the response failed, no transaction ID was set by request.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -561,10 +560,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages3)
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
msg->header.message_type = RTMP_MSG_AMF3CommandMessage;
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Decode the response failed, no transaction ID was set by request.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -579,10 +578,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages3)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the response packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -597,10 +596,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages3)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the response packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -615,10 +614,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages3)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the response packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -633,10 +632,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages3)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the response packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -652,10 +651,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages3)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the response packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -671,10 +670,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages3)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the response packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
}
@ -690,10 +689,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages4)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the request packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -704,10 +703,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages4)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the request packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -718,10 +717,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages4)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the request packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -732,10 +731,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages4)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the request packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -746,10 +745,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages4)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the request packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -760,10 +759,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages4)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the request packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -774,10 +773,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages4)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the request packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -788,10 +787,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages4)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the request packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -802,10 +801,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages4)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the request packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -816,9 +815,9 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages4)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
HELPER_EXPECT_SUCCESS(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -829,10 +828,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages4)
SrsCommonMessage *msg = _create_amf0((char *)bytes, sizeof(bytes), 1);
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the request packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
if (true) {
@ -844,10 +843,10 @@ VOID TEST(ProtocolRTMPTest, OnDecodeMessages4)
msg->header.message_type = RTMP_MSG_AMF0CommandMessage;
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt;
SrsRtmpCommand *pkt;
// Without enough data, it fail when decoding the request packet.
HELPER_EXPECT_FAILED(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
}
@ -2134,7 +2133,7 @@ VOID TEST(ProtocolRTMPTest, ServerResponseCommands)
srs_freep(pkt);
// onStatus(NetStream.Data.Start)
SrsPacket *bpkt = NULL;
SrsRtmpCommand *bpkt = NULL;
HELPER_ASSERT_SUCCESS(p.expect_message(&msg, &bpkt));
srs_freep(msg);
srs_freep(bpkt);
@ -2682,9 +2681,9 @@ VOID TEST(ProtocolRTMPTest, AgentMessageCodec)
HELPER_ASSERT_SUCCESS(p.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt = NULL;
SrsRtmpCommand *pkt = NULL;
HELPER_EXPECT_SUCCESS(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
}
@ -2720,14 +2719,14 @@ VOID TEST(ProtocolRTMPTest, AgentMessageCodec)
HELPER_ASSERT_SUCCESS(p.recv_message(&msg));
SrsUniquePtr<SrsCommonMessage> msg_uptr(msg);
SrsPacket *pkt = NULL;
SrsRtmpCommand *pkt = NULL;
HELPER_EXPECT_SUCCESS(p.decode_message(msg, &pkt));
SrsUniquePtr<SrsPacket> pkt_uptr(pkt);
SrsUniquePtr<SrsRtmpCommand> pkt_uptr(pkt);
}
}
}
srs_error_t _mock_packet_to_shared_msg(SrsPacket *packet, int stream_id, SrsSharedPtrMessage *shared_msg)
srs_error_t _mock_packet_to_shared_msg(SrsRtmpCommand *packet, int stream_id, SrsMediaPacket *shared_msg)
{
srs_error_t err = srs_success;
@ -2739,9 +2738,7 @@ srs_error_t _mock_packet_to_shared_msg(SrsPacket *packet, int stream_id, SrsShar
return err;
}
if ((err = shared_msg->create(msg)) != srs_success) {
return err;
}
msg->to_msg(shared_msg);
return err;
}
@ -2755,18 +2752,18 @@ VOID TEST(ProtocolRTMPTest, CheckStreamID)
SrsRtmpClient p(&io);
if (true) {
SrsSharedPtrMessage *shared_msgs[2];
SrsMediaPacket *shared_msgs[2];
SrsConnectAppPacket *res = new SrsConnectAppPacket();
SrsUniquePtr<SrsConnectAppPacket> res_uptr(res);
if (true) {
SrsSharedPtrMessage *shared_msg = new SrsSharedPtrMessage();
SrsMediaPacket *shared_msg = new SrsMediaPacket();
HELPER_ASSERT_SUCCESS(_mock_packet_to_shared_msg(res, 1, shared_msg));
shared_msgs[0] = shared_msg;
}
if (true) {
SrsSharedPtrMessage *shared_msg = new SrsSharedPtrMessage();
SrsMediaPacket *shared_msg = new SrsMediaPacket();
HELPER_ASSERT_SUCCESS(_mock_packet_to_shared_msg(res, 2, shared_msg));
shared_msgs[1] = shared_msg;
}
@ -2800,7 +2797,7 @@ VOID TEST(ProtocolRTMPTest, AgentMessageTransform)
SrsRtmpClient p(&io);
if (true) {
SrsSharedPtrMessage *shared_msg = new SrsSharedPtrMessage();
SrsMediaPacket *shared_msg = new SrsMediaPacket();
SrsConnectAppPacket *res = new SrsConnectAppPacket();
HELPER_ASSERT_SUCCESS(_mock_packet_to_shared_msg(res, 1, shared_msg));
srs_freep(res);
@ -2821,7 +2818,7 @@ VOID TEST(ProtocolRTMPTest, AgentMessageTransform)
SrsRtmpClient p(&io);
if (true) {
SrsSharedPtrMessage *shared_msg = new SrsSharedPtrMessage();
SrsMediaPacket *shared_msg = new SrsMediaPacket();
SrsConnectAppPacket *res = new SrsConnectAppPacket();
HELPER_ASSERT_SUCCESS(_mock_packet_to_shared_msg(res, 1, shared_msg));
srs_freep(res);
@ -2842,7 +2839,7 @@ VOID TEST(ProtocolRTMPTest, AgentMessageTransform)
SrsRtmpServer p(&io);
if (true) {
SrsSharedPtrMessage *shared_msg = new SrsSharedPtrMessage();
SrsMediaPacket *shared_msg = new SrsMediaPacket();
SrsConnectAppPacket *res = new SrsConnectAppPacket();
HELPER_ASSERT_SUCCESS(_mock_packet_to_shared_msg(res, 1, shared_msg));
srs_freep(res);
@ -2863,7 +2860,7 @@ VOID TEST(ProtocolRTMPTest, AgentMessageTransform)
SrsRtmpServer p(&io);
if (true) {
SrsSharedPtrMessage *shared_msg = new SrsSharedPtrMessage();
SrsMediaPacket *shared_msg = new SrsMediaPacket();
SrsConnectAppPacket *res = new SrsConnectAppPacket();
HELPER_ASSERT_SUCCESS(_mock_packet_to_shared_msg(res, 1, shared_msg));
srs_freep(res);
@ -2929,7 +2926,7 @@ VOID TEST(ProtocolRTMPTest, CreateRTMPMessage)
// Invalid message type.
if (true) {
SrsSharedPtrMessage *msg = NULL;
SrsCommonMessage *msg = NULL;
HELPER_EXPECT_FAILED(srs_rtmp_create_msg(SrsFrameTypeForbidden, 0, _strcpy("Hello"), 5, 0, &msg));
EXPECT_TRUE(NULL == msg);
}
@ -2941,7 +2938,7 @@ VOID TEST(ProtocolRTMPTest, CreateRTMPMessage)
// Normal script message.
if (true) {
SrsSharedPtrMessage *msg = NULL;
SrsCommonMessage *msg = NULL;
HELPER_EXPECT_SUCCESS(srs_rtmp_create_msg(SrsFrameTypeScript, 0, _strcpy("Hello"), 5, 0, &msg));
EXPECT_STREQ("Hello", msg->payload());
srs_freep(msg);
@ -2949,7 +2946,7 @@ VOID TEST(ProtocolRTMPTest, CreateRTMPMessage)
// Normal video message.
if (true) {
SrsSharedPtrMessage *msg = NULL;
SrsCommonMessage *msg = NULL;
HELPER_EXPECT_SUCCESS(srs_rtmp_create_msg(SrsFrameTypeVideo, 0, _strcpy("Hello"), 5, 0, &msg));
EXPECT_STREQ("Hello", msg->payload());
srs_freep(msg);
@ -2957,7 +2954,7 @@ VOID TEST(ProtocolRTMPTest, CreateRTMPMessage)
// Normal audio message.
if (true) {
SrsSharedPtrMessage *msg = NULL;
SrsCommonMessage *msg = NULL;
HELPER_EXPECT_SUCCESS(srs_rtmp_create_msg(SrsFrameTypeAudio, 0, _strcpy("Hello"), 5, 0, &msg));
EXPECT_STREQ("Hello", msg->payload());
srs_freep(msg);
@ -3046,8 +3043,8 @@ VOID TEST(ProtocolRTMPTest, OthersAll)
SrsMessageArray *parr = &h;
SrsUniquePtr<SrsMessageArray> parr2(parr, srs_utest_free_message_array);
h.msgs[0] = new SrsSharedPtrMessage();
h.msgs[1] = new SrsSharedPtrMessage();
h.msgs[0] = new SrsMediaPacket();
h.msgs[1] = new SrsMediaPacket();
EXPECT_TRUE(NULL != h.msgs[0]);
EXPECT_TRUE(NULL != h.msgs[1]);