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

UniquePtr: Support SrsUniquePtr to replace SrsAutoFree. v6.0.136 (#4109)

Browse source 
To manage an object:

```cpp
// Before
MyClass* ptr = new MyClass();
SrsAutoFree(MyClass, ptr);
ptr->do_something();

// Now
SrsUniquePtr<MyClass> ptr(new MyClass());
ptr->do_something();
```

To manage an array of objects:

```cpp
// Before
char* ptr = new char[10];
SrsAutoFreeA(char, ptr);
ptr[0] = 0xf;

// Now
SrsUniquePtr<char[]> ptr(new char[10]);
ptr[0] = 0xf;
```

In fact, SrsUniquePtr is a limited subset of SrsAutoFree, mainly
managing pointers and arrays. SrsUniquePtr is better than SrsAutoFree
because it has the same API to standard unique ptr.

```cpp
SrsUniquePtr<MyClass> ptr(new MyClass());
ptr->do_something();
MyClass* p = ptr.get();
```

SrsAutoFree actually uses a pointer to a pointer, so it can be set to
NULL, allowing the pointer's value to be changed later (this usage is
different from SrsUniquePtr).

```cpp
// OK to free ptr correctly.
MyClass* ptr;
SrsAutoFree(MyClass, ptr);
ptr = new MyClass();

// Crash because ptr is an invalid pointer.
MyClass* ptr;
SrsUniquePtr<MyClass> ptr(ptr);
ptr = new MyClass();
```

Additionally, SrsAutoFreeH can use specific release functions, which
SrsUniquePtr does not support.

---------

Co-authored-by: Jacob Su <suzp1984@gmail.com>
This commit is contained in:
Winlin 2024-07-09 10:29:36 +08:00 • committed by GitHub
parent baf22d01c1
commit 23d2602c34
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
72 changed files with 1720 additions and 1669 deletions
Download patch file Download diff file Expand all files Collapse all files

5
trunk/src/app/srs_app_caster_flv.cpp
View file

@ -215,10 +215,7 @@ srs_error_t SrsDynamicHttpConn::proxy(ISrsHttpResponseWriter* w, ISrsHttpMessage
output = o;
srs_trace("flv: proxy %s:%d %s to %s", ip.c_str(), port, r->uri().c_str(), output.c_str());
char* buffer = new char[SRS_HTTP_FLV_STREAM_BUFFER];
SrsAutoFreeA(char, buffer);
ISrsHttpResponseReader* rr = r->body_reader();
SrsHttpFileReader reader(rr);
SrsFlvDecoder dec;

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

@ -1157,13 +1157,13 @@ srs_error_t SrsConfDirective::parse_conf(SrsConfigBuffer* buffer, SrsDirectiveCo
srs_assert(!file.empty());
srs_trace("config parse include %s", file.c_str());
SrsConfigBuffer* include_file_buffer = NULL;
SrsAutoFree(SrsConfigBuffer, include_file_buffer);
if ((err = conf->build_buffer(file, &include_file_buffer)) != srs_success) {
SrsConfigBuffer* include_file_buffer_raw = NULL;
if ((err = conf->build_buffer(file, &include_file_buffer_raw)) != srs_success) {
return srs_error_wrap(err, "buffer fullfill %s", file.c_str());
}
SrsUniquePtr<SrsConfigBuffer> include_file_buffer(include_file_buffer_raw);
if ((err = parse_conf(include_file_buffer, SrsDirectiveContextFile, conf)) != srs_success) {
if ((err = parse_conf(include_file_buffer.get(), SrsDirectiveContextFile, conf)) != srs_success) {
return srs_error_wrap(err, "parse include buffer %s", file.c_str());
}
}
@ -1628,10 +1628,8 @@ srs_error_t SrsConfig::reload_vhost(SrsConfDirective* old_root)
srs_error_t SrsConfig::reload_conf(SrsConfig* conf)
{
srs_error_t err = srs_success;
SrsConfDirective* old_root = root;
SrsAutoFree(SrsConfDirective, old_root);
SrsUniquePtr<SrsConfDirective> old_root(root);
root = conf->root;
conf->root = NULL;
@ -1665,14 +1663,14 @@ srs_error_t SrsConfig::reload_conf(SrsConfig* conf)
}
// Merge config: rtc_server
if ((err = reload_rtc_server(old_root)) != srs_success) {
if ((err = reload_rtc_server(old_root.get())) != srs_success) {
return srs_error_wrap(err, "http steram");;
}
// TODO: FIXME: support reload stream_caster.
// merge config: vhost
if ((err = reload_vhost(old_root)) != srs_success) {
if ((err = reload_vhost(old_root.get())) != srs_success) {
return srs_error_wrap(err, "vhost");;
}
@ -2260,13 +2258,13 @@ srs_error_t SrsConfig::parse_file(const char* filename)
return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "empty config");
}
SrsConfigBuffer* buffer = NULL;
SrsAutoFree(SrsConfigBuffer, buffer);
if ((err = build_buffer(config_file, &buffer)) != srs_success) {
SrsConfigBuffer* buffer_raw = NULL;
if ((err = build_buffer(config_file, &buffer_raw)) != srs_success) {
return srs_error_wrap(err, "buffer fullfill %s", filename);
}
if ((err = parse_buffer(buffer)) != srs_success) {
SrsUniquePtr<SrsConfigBuffer> buffer(buffer_raw);
if ((err = parse_buffer(buffer.get())) != srs_success) {
return srs_error_wrap(err, "parse buffer %s", filename);
}

9
trunk/src/app/srs_app_conn.cpp
View file

@ -902,19 +902,18 @@ srs_error_t SrsSslConnection::read(void* plaintext, size_t nn_plaintext, ssize_t
if (r0 == -1 && r1 == SSL_ERROR_WANT_READ) {
// TODO: Can we avoid copy?
int nn_cipher = nn_plaintext;
char* cipher = new char[nn_cipher];
SrsAutoFreeA(char, cipher);
SrsUniquePtr<char[]> cipher(new char[nn_cipher]);
// Read the cipher from SSL.
ssize_t nn = 0;
if ((err = transport->read(cipher, nn_cipher, &nn)) != srs_success) {
if ((err = transport->read(cipher.get(), nn_cipher, &nn)) != srs_success) {
return srs_error_wrap(err, "https: read");
}
int r0 = BIO_write(bio_in, cipher, nn);
int r0 = BIO_write(bio_in, cipher.get(), nn);
if (r0 <= 0) {
// TODO: 0 or -1 maybe block, use BIO_should_retry to check.
return srs_error_new(ERROR_HTTPS_READ, "BIO_write r0=%d, cipher=%p, size=%d", r0, cipher, nn);
return srs_error_new(ERROR_HTTPS_READ, "BIO_write r0=%d, cipher=%p, size=%d", r0, cipher.get(), nn);
}
continue;
}

14
trunk/src/app/srs_app_dash.cpp
View file

@ -293,10 +293,9 @@ srs_error_t SrsMpdWriter::write(SrsFormat* format, SrsFragmentWindow* afragments
}
ss << " </Period>" << endl;
ss << "</MPD>" << endl;
SrsFileWriter* fw = new SrsFileWriter();
SrsAutoFree(SrsFileWriter, fw);
SrsUniquePtr<SrsFileWriter> fw(new SrsFileWriter());
string full_path_tmp = full_path + ".tmp";
if ((err = fw->open(full_path_tmp)) != srs_success) {
return srs_error_wrap(err, "Open MPD file=%s failed", full_path_tmp.c_str());
@ -651,10 +650,9 @@ srs_error_t SrsDashController::refresh_init_mp4(SrsSharedPtrMessage* msg, SrsFor
} else {
path += "/audio-init.mp4";
}
SrsInitMp4* init_mp4 = new SrsInitMp4();
SrsAutoFree(SrsInitMp4, init_mp4);
SrsUniquePtr<SrsInitMp4> init_mp4(new SrsInitMp4());
init_mp4->set_path(path);
int tid = msg->is_video()? video_track_id : audio_track_id;

67
trunk/src/app/srs_app_dvr.cpp
View file

@ -119,19 +119,19 @@ srs_error_t SrsDvrSegmenter::write_metadata(SrsSharedPtrMessage* metadata)
srs_error_t SrsDvrSegmenter::write_audio(SrsSharedPtrMessage* shared_audio, SrsFormat* format)
{
srs_error_t err = srs_success;
SrsSharedPtrMessage* audio = shared_audio->copy();
SrsAutoFree(SrsSharedPtrMessage, audio);
if ((err = jitter->correct(audio, jitter_algorithm)) != srs_success) {
// TODO: FIXME: Use SrsSharedPtr instead.
SrsUniquePtr<SrsSharedPtrMessage> audio(shared_audio->copy());
if ((err = jitter->correct(audio.get(), jitter_algorithm)) != srs_success) {
return srs_error_wrap(err, "jitter");
}
if ((err = on_update_duration(audio)) != srs_success) {
if ((err = on_update_duration(audio.get())) != srs_success) {
return srs_error_wrap(err, "update duration");
}
if ((err = encode_audio(audio, format)) != srs_success) {
if ((err = encode_audio(audio.get(), format)) != srs_success) {
return srs_error_wrap(err, "encode audio");
}
@ -141,19 +141,19 @@ srs_error_t SrsDvrSegmenter::write_audio(SrsSharedPtrMessage* shared_audio, SrsF
srs_error_t SrsDvrSegmenter::write_video(SrsSharedPtrMessage* shared_video, SrsFormat* format)
{
srs_error_t err = srs_success;
SrsSharedPtrMessage* video = shared_video->copy();
SrsAutoFree(SrsSharedPtrMessage, video);
if ((err = jitter->correct(video, jitter_algorithm)) != srs_success) {
// TODO: FIXME: Use SrsSharedPtr instead.
SrsUniquePtr<SrsSharedPtrMessage> video(shared_video->copy());
if ((err = jitter->correct(video.get(), jitter_algorithm)) != srs_success) {
return srs_error_wrap(err, "jitter");
}
if ((err = encode_video(video, format)) != srs_success) {
if ((err = encode_video(video.get(), format)) != srs_success) {
return srs_error_wrap(err, "encode video");
}
if ((err = on_update_duration(video)) != srs_success) {
if ((err = on_update_duration(video.get())) != srs_success) {
return srs_error_wrap(err, "update duration");
}
@ -256,15 +256,12 @@ srs_error_t SrsDvrFlvSegmenter::refresh_metadata()
int64_t cur = fs->tellg();
// buffer to write the size.
char* buf = new char[SrsAmf0Size::number()];
SrsAutoFreeA(char, buf);
SrsBuffer stream(buf, SrsAmf0Size::number());
SrsUniquePtr<char[]> buf(new char[SrsAmf0Size::number()]);
SrsBuffer stream(buf.get(), SrsAmf0Size::number());
// filesize to buf.
SrsAmf0Any* size = SrsAmf0Any::number((double)cur);
SrsAutoFree(SrsAmf0Any, size);
SrsUniquePtr<SrsAmf0Any> size(SrsAmf0Any::number((double)cur));
stream.skip(-1 * stream.pos());
if ((err = size->write(&stream)) != srs_success) {
return srs_error_wrap(err, "write filesize");
@ -272,14 +269,13 @@ srs_error_t SrsDvrFlvSegmenter::refresh_metadata()
// update the flesize.
fs->seek2(filesize_offset);
if ((err = fs->write(buf, SrsAmf0Size::number(), NULL)) != srs_success) {
if ((err = fs->write(buf.get(), SrsAmf0Size::number(), NULL)) != srs_success) {
return srs_error_wrap(err, "update filesize");
}
// duration to buf
SrsAmf0Any* dur = SrsAmf0Any::number((double)srsu2ms(fragment->duration()) / 1000.0);
SrsAutoFree(SrsAmf0Any, dur);
SrsUniquePtr<SrsAmf0Any> dur(SrsAmf0Any::number((double)srsu2ms(fragment->duration()) / 1000.0));
stream.skip(-1 * stream.pos());
if ((err = dur->write(&stream)) != srs_success) {
return srs_error_wrap(err, "write duration");
@ -287,7 +283,7 @@ srs_error_t SrsDvrFlvSegmenter::refresh_metadata()
// update the duration
fs->seek2(duration_offset);
if ((err = fs->write(buf, SrsAmf0Size::number(), NULL)) != srs_success) {
if ((err = fs->write(buf.get(), SrsAmf0Size::number(), NULL)) != srs_success) {
return srs_error_wrap(err, "update duration");
}
@ -332,15 +328,13 @@ srs_error_t SrsDvrFlvSegmenter::encode_metadata(SrsSharedPtrMessage* metadata)
}
SrsBuffer stream(metadata->payload, metadata->size);
SrsAmf0Any* name = SrsAmf0Any::str();
SrsAutoFree(SrsAmf0Any, name);
SrsUniquePtr<SrsAmf0Any> name(SrsAmf0Any::str());
if ((err = name->read(&stream)) != srs_success) {
return srs_error_wrap(err, "read name");
}
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsUniquePtr<SrsAmf0Object> obj(SrsAmf0Any::object());
if ((err = obj->read(&stream)) != srs_success) {
return srs_error_wrap(err, "read object");
}
@ -355,16 +349,15 @@ srs_error_t SrsDvrFlvSegmenter::encode_metadata(SrsSharedPtrMessage* metadata)
obj->set("duration", SrsAmf0Any::number(0));
int size = name->total_size() + obj->total_size();
char* payload = new char[size];
SrsAutoFreeA(char, payload);
SrsUniquePtr<char[]> payload(new char[size]);
// 11B flv header, 3B object EOF, 8B number value, 1B number flag.
duration_offset = fs->tellg() + size + 11 - SrsAmf0Size::object_eof() - SrsAmf0Size::number();
// 2B string flag, 8B number value, 8B string 'duration', 1B number flag
filesize_offset = duration_offset - SrsAmf0Size::utf8("duration") - SrsAmf0Size::number();
// convert metadata to bytes.
SrsBuffer buf(payload, size);
SrsBuffer buf(payload.get(), size);
if ((err = name->write(&buf)) != srs_success) {
return srs_error_wrap(err, "write name");
@ -374,7 +367,7 @@ srs_error_t SrsDvrFlvSegmenter::encode_metadata(SrsSharedPtrMessage* metadata)
}
// to flv file.
if ((err = enc->write_metadata(18, payload, size)) != srs_success) {
if ((err = enc->write_metadata(18, payload.get(), size)) != srs_success) {
return srs_error_wrap(err, "write metadata");
}

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

@ -112,8 +112,8 @@ srs_error_t SrsEdgeRtmpUpstream::connect(SrsRequest* r, SrsLbRoundRobin* lb)
#ifdef SRS_APM
// Create a client span and store it to an AMF0 propagator.
ISrsApmSpan* span_client = _srs_apm->inject(_srs_apm->span("edge-pull")->set_kind(SrsApmKindClient)->as_child(_srs_apm->load()), sdk->extra_args());
SrsAutoFree(ISrsApmSpan, span_client);
SrsUniquePtr<ISrsApmSpan> span_client(_srs_apm->inject(_srs_apm->span("edge-pull")->set_kind(SrsApmKindClient)
->as_child(_srs_apm->load()), sdk->extra_args()));
#endif
if ((err = sdk->connect()) != srs_success) {
@ -594,9 +594,8 @@ srs_error_t SrsEdgeIngester::do_cycle()
srs_error_t SrsEdgeIngester::ingest(string& redirect)
{
srs_error_t err = srs_success;
SrsPithyPrint* pprint = SrsPithyPrint::create_edge();
SrsAutoFree(SrsPithyPrint, pprint);
SrsUniquePtr<SrsPithyPrint> pprint(SrsPithyPrint::create_edge());
// we only use the redict once.
// reset the redirect to empty, for maybe the origin changed.
@ -615,15 +614,15 @@ srs_error_t SrsEdgeIngester::ingest(string& redirect)
}
// read from client.
SrsCommonMessage* msg = NULL;
if ((err = upstream->recv_message(&msg)) != srs_success) {
SrsCommonMessage* msg_raw = NULL;
if ((err = upstream->recv_message(&msg_raw)) != srs_success) {
return srs_error_wrap(err, "recv message");
}
srs_assert(msg);
SrsAutoFree(SrsCommonMessage, msg);
if ((err = process_publish_message(msg, redirect)) != srs_success) {
srs_assert(msg_raw);
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
if ((err = process_publish_message(msg.get(), redirect)) != srs_success) {
return srs_error_wrap(err, "process message");
}
}
@ -659,14 +658,14 @@ 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 = NULL;
if ((err = upstream->decode_message(msg, &pkt)) != srs_success) {
SrsPacket* pkt_raw = NULL;
if ((err = upstream->decode_message(msg, &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "decode message");
}
SrsAutoFree(SrsPacket, pkt);
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
if (dynamic_cast<SrsOnMetaDataPacket*>(pkt)) {
SrsOnMetaDataPacket* metadata = dynamic_cast<SrsOnMetaDataPacket*>(pkt);
if (dynamic_cast<SrsOnMetaDataPacket*>(pkt.get())) {
SrsOnMetaDataPacket* metadata = dynamic_cast<SrsOnMetaDataPacket*>(pkt.get());
if ((err = source_->on_meta_data(msg, metadata)) != srs_success) {
return srs_error_wrap(err, "source consume metadata");
}
@ -678,15 +677,15 @@ 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 = NULL;
if ((err = upstream->decode_message(msg, &pkt)) != srs_success) {
SrsPacket* pkt_raw = NULL;
if ((err = upstream->decode_message(msg, &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "decode message");
}
SrsAutoFree(SrsPacket, pkt);
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
// RTMP 302 redirect
if (dynamic_cast<SrsCallPacket*>(pkt)) {
SrsCallPacket* call = dynamic_cast<SrsCallPacket*>(pkt);
if (dynamic_cast<SrsCallPacket*>(pkt.get())) {
SrsCallPacket* call = dynamic_cast<SrsCallPacket*>(pkt.get());
if (!call->arguments->is_object()) {
return err;
}
@ -793,8 +792,8 @@ srs_error_t SrsEdgeForwarder::start()
#ifdef SRS_APM
// Create a client span and store it to an AMF0 propagator.
// Note that we are able to load the span from coroutine context because in the same coroutine.
ISrsApmSpan* span_client = _srs_apm->inject(_srs_apm->span("edge-push")->set_kind(SrsApmKindClient)->as_child(_srs_apm->load()), sdk->extra_args());
SrsAutoFree(ISrsApmSpan, span_client);
SrsUniquePtr<ISrsApmSpan> span_client(_srs_apm->inject(_srs_apm->span("edge-push")->set_kind(SrsApmKindClient)
->as_child(_srs_apm->load()), sdk->extra_args()));
#endif
if ((err = sdk->connect()) != srs_success) {
@ -858,10 +857,8 @@ srs_error_t SrsEdgeForwarder::do_cycle()
srs_error_t err = srs_success;
sdk->set_recv_timeout(SRS_CONSTS_RTMP_PULSE);
SrsPithyPrint* pprint = SrsPithyPrint::create_edge();
SrsAutoFree(SrsPithyPrint, pprint);
SrsUniquePtr<SrsPithyPrint> pprint(SrsPithyPrint::create_edge());
SrsMessageArray msgs(SYS_MAX_EDGE_SEND_MSGS);
while (true) {

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

@ -246,10 +246,9 @@ srs_error_t SrsForwarder::forward()
srs_error_t err = srs_success;
sdk->set_recv_timeout(SRS_CONSTS_RTMP_PULSE);
SrsPithyPrint* pprint = SrsPithyPrint::create_forwarder();
SrsAutoFree(SrsPithyPrint, pprint);
SrsUniquePtr<SrsPithyPrint> pprint(SrsPithyPrint::create_forwarder());
SrsMessageArray msgs(SYS_MAX_FORWARD_SEND_MSGS);
// update sequence header

19
trunk/src/app/srs_app_gb28181.cpp
View file

@ -164,8 +164,7 @@ void SrsGbSession::on_ps_pack(SrsPackContext* ctx, SrsPsPacket* ps, const std::v
media_reserved_ = ctx->media_reserved_;
// Group all video in pack to a video frame, because only allows one video for each PS pack.
SrsTsMessage* video = new SrsTsMessage();
SrsAutoFree(SrsTsMessage, video);
SrsUniquePtr<SrsTsMessage> video(new SrsTsMessage());
for (vector<SrsTsMessage*>::const_iterator it = msgs.begin(); it != msgs.end(); ++it) {
SrsTsMessage* msg = *it;
@ -190,7 +189,7 @@ void SrsGbSession::on_ps_pack(SrsPackContext* ctx, SrsPsPacket* ps, const std::v
// Send the generated video message.
if (video->payload->length() > 0) {
srs_error_t err = muxer_->on_ts_message(video);
srs_error_t err = muxer_->on_ts_message(video.get());
if (err != srs_success) {
srs_warn("Muxer: Ignore video err %s", srs_error_desc(err).c_str());
srs_freep(err);
@ -1051,8 +1050,7 @@ srs_error_t SrsGbSipTcpReceiver::do_cycle()
{
srs_error_t err = srs_success;
SrsHttpParser* parser = new SrsHttpParser();
SrsAutoFree(SrsHttpParser, parser);
SrsUniquePtr<SrsHttpParser> parser(new SrsHttpParser());
// We might get SIP request or response message.
if ((err = parser->initialize(HTTP_BOTH)) != srs_success) {
@ -1065,14 +1063,14 @@ srs_error_t SrsGbSipTcpReceiver::do_cycle()
}
// Use HTTP parser to parse SIP messages.
ISrsHttpMessage* hmsg = NULL;
SrsAutoFree(ISrsHttpMessage, hmsg);
if ((err = parser->parse_message(conn_, &hmsg)) != srs_success) {
ISrsHttpMessage* hmsg_raw = NULL;
if ((err = parser->parse_message(conn_, &hmsg_raw)) != srs_success) {
return srs_error_wrap(err, "parse message");
}
SrsUniquePtr<ISrsHttpMessage> hmsg(hmsg_raw);
SrsSipMessage smsg;
if ((err = smsg.parse(hmsg)) != srs_success) {
if ((err = smsg.parse(hmsg.get())) != srs_success) {
srs_warn("SIP: Drop msg type=%d, method=%d, err is %s", hmsg->message_type(), hmsg->method(), srs_error_summary(err).c_str());
srs_freep(err); continue;
}
@ -1156,9 +1154,8 @@ srs_error_t SrsGbSipTcpSender::do_cycle()
return srs_error_wrap(err, "pull");
}
SrsSipMessage* msg = msgs_.front();
SrsUniquePtr<SrsSipMessage> msg(msgs_.front());
msgs_.erase(msgs_.begin());
SrsAutoFree(SrsSipMessage, msg);
if (msg->type_ == HTTP_RESPONSE) {
SrsSipResponseWriter res(conn_);

24
trunk/src/app/srs_app_hds.cpp
View file

@ -43,10 +43,9 @@ string serialFlv(SrsSharedPtrMessage *msg)
{
int size = 15 + msg->size;
char *byte = new char[size];
SrsBuffer *stream = new SrsBuffer(byte, size);
SrsAutoFree(SrsBuffer, stream);
SrsUniquePtr<SrsBuffer> stream(new SrsBuffer(byte, size));
// tag header
long long dts = msg->timestamp;
char type = msg->is_video() ? 0x09 : 0x08;
@ -449,17 +448,16 @@ srs_error_t SrsHds::flush_bootstrap()
srs_error_t err = srs_success;
int size = 1024*100;
char *start_abst = new char[1024*100];
SrsAutoFreeA(char, start_abst);
SrsUniquePtr<char[]> start_abst(new char[1024*100]);
int size_abst = 0;
char *start_asrt = NULL;
int size_asrt = 0;
char *start_afrt = NULL;
int size_afrt = 0;
SrsBuffer abst(start_abst, size);
SrsBuffer abst(start_abst.get(), size);
// @see video_file_format_spec_v10_1
// page: 46
@ -554,7 +552,7 @@ srs_error_t SrsHds::flush_bootstrap()
abst.write_1bytes(1);
size_abst += 1;
start_asrt = start_abst + size_abst;
start_asrt = start_abst.get() + size_abst;
// follows by asrt
abst.write_4bytes(0);
@ -622,7 +620,7 @@ srs_error_t SrsHds::flush_bootstrap()
size_abst += 1;
// follows by afrt
start_afrt = start_abst + size_abst;
start_afrt = start_abst.get() + size_abst;
abst.write_4bytes(0);
abst.write_string("afrt");
@ -672,7 +670,7 @@ srs_error_t SrsHds::flush_bootstrap()
update_box(start_afrt, size_afrt);
size_abst += size_afrt;
update_box(start_abst, size_abst);
update_box(start_abst.get(), size_abst);
string path = _srs_config->get_hds_path(hds_req->vhost) + "/" + hds_req->app + "/" + hds_req->stream +".abst";
@ -681,7 +679,7 @@ srs_error_t SrsHds::flush_bootstrap()
return srs_error_new(ERROR_HDS_OPEN_BOOTSTRAP_FAILED, "open bootstrap file failed, path=%s", path.c_str());
}
if (write(fd, start_abst, size_abst) != size_abst) {
if (write(fd, start_abst.get(), size_abst) != size_abst) {
close(fd);
return srs_error_new(ERROR_HDS_WRITE_BOOTSTRAP_FAILED, "write bootstrap file failed, path=", path.c_str());
}

14
trunk/src/app/srs_app_heartbeat.cpp
View file

@ -55,10 +55,9 @@ srs_error_t SrsHttpHeartbeat::do_heartbeat()
if (!ips.empty()) {
ip = ips[_srs_config->get_stats_network() % (int)ips.size()];
}
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("device_id", SrsJsonAny::str(device_id.c_str()));
obj->set("ip", SrsJsonAny::str(ip->ip.c_str()));
@ -75,11 +74,12 @@ srs_error_t SrsHttpHeartbeat::do_heartbeat()
}
std::string req = obj->dumps();
ISrsHttpMessage* msg = NULL;
if ((err = http.post(uri.get_path(), req, &msg)) != srs_success) {
ISrsHttpMessage* msg_raw = NULL;
if ((err = http.post(uri.get_path(), req, &msg_raw)) != srs_success) {
return srs_error_wrap(err, "http post hartbeart uri failed. url=%s, request=%s", url.c_str(), req.c_str());
}
SrsAutoFree(ISrsHttpMessage, msg);
SrsUniquePtr<ISrsHttpMessage> msg(msg_raw);
std::string res;
if ((err = msg->body_read_all(res)) != srs_success) {

18
trunk/src/app/srs_app_hls.cpp
View file

@ -1373,10 +1373,9 @@ srs_error_t SrsHls::on_audio(SrsSharedPtrMessage* shared_audio, SrsFormat* forma
// update the hls time, for hls_dispose.
last_update_time = srs_get_system_time();
SrsSharedPtrMessage* audio = shared_audio->copy();
SrsAutoFree(SrsSharedPtrMessage, audio);
SrsUniquePtr<SrsSharedPtrMessage> audio(shared_audio->copy());
// ts support audio codec: aac/mp3
SrsAudioCodecId acodec = format->acodec->id;
if (acodec != SrsAudioCodecIdAAC && acodec != SrsAudioCodecIdMP3) {
@ -1390,7 +1389,7 @@ srs_error_t SrsHls::on_audio(SrsSharedPtrMessage* shared_audio, SrsFormat* forma
}
// TODO: FIXME: config the jitter of HLS.
if ((err = jitter->correct(audio, SrsRtmpJitterAlgorithmOFF)) != srs_success) {
if ((err = jitter->correct(audio.get(), SrsRtmpJitterAlgorithmOFF)) != srs_success) {
return srs_error_wrap(err, "hls: jitter");
}
@ -1455,10 +1454,9 @@ srs_error_t SrsHls::on_video(SrsSharedPtrMessage* shared_video, SrsFormat* forma
// update the hls time, for hls_dispose.
last_update_time = srs_get_system_time();
SrsSharedPtrMessage* video = shared_video->copy();
SrsAutoFree(SrsSharedPtrMessage, video);
SrsUniquePtr<SrsSharedPtrMessage> video(shared_video->copy());
// ignore info frame,
// @see https://github.com/ossrs/srs/issues/288#issuecomment-69863909
srs_assert(format->video);
@ -1477,7 +1475,7 @@ srs_error_t SrsHls::on_video(SrsSharedPtrMessage* shared_video, SrsFormat* forma
}
// TODO: FIXME: config the jitter of HLS.
if ((err = jitter->correct(video, SrsRtmpJitterAlgorithmOFF)) != srs_success) {
if ((err = jitter->correct(video.get(), SrsRtmpJitterAlgorithmOFF)) != srs_success) {
return srs_error_wrap(err, "hls: jitter");
}

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

@ -66,9 +66,8 @@ srs_error_t srs_api_response_jsonp(ISrsHttpResponseWriter* w, string callback, s
srs_error_t srs_api_response_jsonp_code(ISrsHttpResponseWriter* w, string callback, int code)
{
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(code));
return srs_api_response_jsonp(w, callback, obj->dumps());
@ -76,8 +75,7 @@ srs_error_t srs_api_response_jsonp_code(ISrsHttpResponseWriter* w, string callba
srs_error_t srs_api_response_jsonp_code(ISrsHttpResponseWriter* w, string callback, srs_error_t err)
{
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(srs_error_code(err)));
@ -104,8 +102,7 @@ srs_error_t srs_api_response_json(ISrsHttpResponseWriter* w, string data)
srs_error_t srs_api_response_json_code(ISrsHttpResponseWriter* w, int code)
{
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(code));
@ -114,8 +111,7 @@ srs_error_t srs_api_response_json_code(ISrsHttpResponseWriter* w, int code)
srs_error_t srs_api_response_json_code(ISrsHttpResponseWriter* w, srs_error_t code)
{
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(srs_error_code(code)));
@ -178,9 +174,8 @@ SrsGoApiRoot::~SrsGoApiRoot()
srs_error_t SrsGoApiRoot::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -218,9 +213,8 @@ SrsGoApiApi::~SrsGoApiApi()
srs_error_t SrsGoApiApi::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -246,9 +240,8 @@ SrsGoApiV1::~SrsGoApiV1()
srs_error_t SrsGoApiV1::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -297,9 +290,8 @@ SrsGoApiVersion::~SrsGoApiVersion()
srs_error_t SrsGoApiVersion::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -328,16 +320,15 @@ SrsGoApiSummaries::~SrsGoApiSummaries()
srs_error_t SrsGoApiSummaries::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
obj->set("service", SrsJsonAny::str(stat->service_id().c_str()));
obj->set("pid", SrsJsonAny::str(stat->service_pid().c_str()));
srs_api_dump_summaries(obj);
srs_api_dump_summaries(obj.get());
return srs_api_response(w, r, obj->dumps());
}
@ -353,9 +344,8 @@ SrsGoApiRusages::~SrsGoApiRusages()
srs_error_t SrsGoApiRusages::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -400,9 +390,8 @@ SrsGoApiSelfProcStats::~SrsGoApiSelfProcStats()
srs_error_t SrsGoApiSelfProcStats::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -479,9 +468,8 @@ SrsGoApiSystemProcStats::~SrsGoApiSystemProcStats()
srs_error_t SrsGoApiSystemProcStats::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -520,9 +508,8 @@ SrsGoApiMemInfos::~SrsGoApiMemInfos()
srs_error_t SrsGoApiMemInfos::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -562,9 +549,8 @@ SrsGoApiAuthors::~SrsGoApiAuthors()
srs_error_t SrsGoApiAuthors::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -591,9 +577,8 @@ SrsGoApiFeatures::~SrsGoApiFeatures()
srs_error_t SrsGoApiFeatures::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -661,9 +646,8 @@ SrsGoApiRequests::~SrsGoApiRequests()
srs_error_t SrsGoApiRequests::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -718,9 +702,8 @@ srs_error_t SrsGoApiVhosts::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessag
if (!vid.empty() && (vhost = stat->find_vhost_by_id(vid)) == NULL) {
return srs_api_response_code(w, r, ERROR_RTMP_VHOST_NOT_FOUND);
}
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -776,9 +759,8 @@ srs_error_t SrsGoApiStreams::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
if (!sid.empty() && (stream = stat->find_stream(sid)) == NULL) {
return srs_api_response_code(w, r, ERROR_RTMP_STREAM_NOT_FOUND);
}
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -838,9 +820,8 @@ srs_error_t SrsGoApiClients::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
if (!client_id.empty() && (client = stat->find_client(client_id)) == NULL) {
return srs_api_response_code(w, r, ERROR_RTMP_CLIENT_NOT_FOUND);
}
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::str(stat->server_id().c_str()));
@ -918,14 +899,13 @@ srs_error_t SrsGoApiRaw::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage*
std::string rpc = r->query_get("rpc");
// the object to return for request.
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
// for rpc=raw, to query the raw api config for http api.
if (rpc == "raw") {
// query global scope.
if ((err = _srs_config->raw_to_json(obj)) != srs_success) {
if ((err = _srs_config->raw_to_json(obj.get())) != srs_success) {
int code = srs_error_code(err);
srs_error_reset(err);
return srs_api_response_code(w, r, code);
@ -989,8 +969,7 @@ SrsGoApiClusters::~SrsGoApiClusters()
srs_error_t SrsGoApiClusters::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
SrsJsonObject* data = SrsJsonAny::object();
@ -1057,8 +1036,7 @@ srs_error_t SrsGoApiTcmalloc::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMess
}
// By default, response the json style response.
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
SrsJsonObject* data = SrsJsonAny::object();

25
trunk/src/app/srs_app_http_conn.cpp
View file

@ -155,14 +155,13 @@ srs_error_t SrsHttpConn::do_cycle()
return srs_error_wrap(err, "start");
}
SrsRequest* last_req = NULL;
SrsAutoFree(SrsRequest, last_req);
// process all http messages.
err = process_requests(&last_req);
SrsRequest* last_req_raw = NULL;
err = process_requests(&last_req_raw);
SrsUniquePtr<SrsRequest> last_req(last_req_raw);
srs_error_t r0 = srs_success;
if ((r0 = on_disconnect(last_req)) != srs_success) {
if ((r0 = on_disconnect(last_req.get())) != srs_success) {
err = srs_error_wrap(err, "on disconnect %s", srs_error_desc(r0).c_str());
srs_freep(r0);
}
@ -180,18 +179,18 @@ srs_error_t SrsHttpConn::process_requests(SrsRequest** preq)
}
// get a http message
ISrsHttpMessage* req = NULL;
if ((err = parser->parse_message(skt, &req)) != srs_success) {
ISrsHttpMessage* req_raw = NULL;
if ((err = parser->parse_message(skt, &req_raw)) != srs_success) {
return srs_error_wrap(err, "parse message");
}
// if SUCCESS, always NOT-NULL.
// always free it in this scope.
srs_assert(req);
SrsAutoFree(ISrsHttpMessage, req);
srs_assert(req_raw);
SrsUniquePtr<ISrsHttpMessage> req(req_raw);
// Attach owner connection to message.
SrsHttpMessage* hreq = (SrsHttpMessage*)req;
SrsHttpMessage* hreq = (SrsHttpMessage*)req.get();
hreq->set_connection(this);
// copy request to last request object.
@ -200,17 +199,17 @@ srs_error_t SrsHttpConn::process_requests(SrsRequest** preq)
// may should discard the body.
SrsHttpResponseWriter writer(skt);
if ((err = handler_->on_http_message(req, &writer)) != srs_success) {
if ((err = handler_->on_http_message(req.get(), &writer)) != srs_success) {
return srs_error_wrap(err, "on http message");
}
// ok, handle http request.
if ((err = process_request(&writer, req, req_id)) != srs_success) {
if ((err = process_request(&writer, req.get(), req_id)) != srs_success) {
return srs_error_wrap(err, "process request=%d", req_id);
}
// After the request is processed.
if ((err = handler_->on_message_done(req, &writer)) != srs_success) {
if ((err = handler_->on_message_done(req.get(), &writer)) != srs_success) {
return srs_error_wrap(err, "on message done");
}

88
trunk/src/app/srs_app_http_hooks.cpp
View file

@ -46,12 +46,9 @@ srs_error_t SrsHttpHooks::on_connect(string url, SrsRequest* req)
srs_error_t err = srs_success;
SrsContextId cid = _srs_context->get_id();
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("server_id", SrsJsonAny::str(stat->server_id().c_str()));
obj->set("service_id", SrsJsonAny::str(stat->service_id().c_str()));
obj->set("action", SrsJsonAny::str("on_connect"));
@ -85,11 +82,8 @@ void SrsHttpHooks::on_close(string url, SrsRequest* req, int64_t send_bytes, int
srs_error_t err = srs_success;
SrsContextId cid = _srs_context->get_id();
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("server_id", SrsJsonAny::str(stat->server_id().c_str()));
obj->set("service_id", SrsJsonAny::str(stat->service_id().c_str()));
@ -125,11 +119,8 @@ srs_error_t SrsHttpHooks::on_publish(string url, SrsRequest* req)
srs_error_t err = srs_success;
SrsContextId cid = _srs_context->get_id();
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("server_id", SrsJsonAny::str(stat->server_id().c_str()));
obj->set("service_id", SrsJsonAny::str(stat->service_id().c_str()));
@ -169,11 +160,8 @@ void SrsHttpHooks::on_unpublish(string url, SrsRequest* req)
srs_error_t err = srs_success;
SrsContextId cid = _srs_context->get_id();
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("server_id", SrsJsonAny::str(stat->server_id().c_str()));
obj->set("service_id", SrsJsonAny::str(stat->service_id().c_str()));
@ -216,11 +204,8 @@ srs_error_t SrsHttpHooks::on_play(string url, SrsRequest* req)
srs_error_t err = srs_success;
SrsContextId cid = _srs_context->get_id();
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("server_id", SrsJsonAny::str(stat->server_id().c_str()));
obj->set("service_id", SrsJsonAny::str(stat->service_id().c_str()));
@ -261,11 +246,8 @@ void SrsHttpHooks::on_stop(string url, SrsRequest* req)
srs_error_t err = srs_success;
SrsContextId cid = _srs_context->get_id();
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("server_id", SrsJsonAny::str(stat->server_id().c_str()));
obj->set("service_id", SrsJsonAny::str(stat->service_id().c_str()));
@ -311,9 +293,7 @@ srs_error_t SrsHttpHooks::on_dvr(SrsContextId c, string url, SrsRequest* req, st
std::string cwd = _srs_config->cwd();
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("server_id", SrsJsonAny::str(stat->server_id().c_str()));
obj->set("service_id", SrsJsonAny::str(stat->service_id().c_str()));
@ -364,9 +344,7 @@ srs_error_t SrsHttpHooks::on_hls(SrsContextId c, string url, SrsRequest* req, st
}
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("server_id", SrsJsonAny::str(stat->server_id().c_str()));
obj->set("service_id", SrsJsonAny::str(stat->service_id().c_str()));
@ -449,21 +427,20 @@ srs_error_t SrsHttpHooks::on_hls_notify(SrsContextId c, std::string url, SrsRequ
}
srs_info("GET %s", path.c_str());
ISrsHttpMessage* msg = NULL;
if ((err = http.get(path.c_str(), "", &msg)) != srs_success) {
ISrsHttpMessage* msg_raw = NULL;
if ((err = http.get(path.c_str(), "", &msg_raw)) != srs_success) {
return srs_error_wrap(err, "http: get %s", url.c_str());
}
SrsAutoFree(ISrsHttpMessage, msg);
SrsUniquePtr<ISrsHttpMessage> msg(msg_raw);
int nb_buf = srs_min(nb_notify, SRS_HTTP_READ_BUFFER);
char* buf = new char[nb_buf];
SrsAutoFreeA(char, buf);
SrsUniquePtr<char[]> buf(new char[nb_buf]);
int nb_read = 0;
ISrsHttpResponseReader* br = msg->body_reader();
while (nb_read < nb_notify && !br->eof()) {
ssize_t nb_bytes = 0;
if ((err = br->read(buf, nb_buf, &nb_bytes)) != srs_success) {
if ((err = br->read(buf.get(), nb_buf, &nb_bytes)) != srs_success) {
break;
}
nb_read += (int)nb_bytes;
@ -490,9 +467,7 @@ srs_error_t SrsHttpHooks::discover_co_workers(string url, string& host, int& por
return srs_error_wrap(err, "http: post %s, status=%d, res=%s", url.c_str(), status_code, res.c_str());
}
SrsJsonObject* robj = NULL;
SrsAutoFree(SrsJsonObject, robj);
SrsJsonObject* robj_raw = NULL;
if (true) {
SrsJsonAny* jr = NULL;
if ((jr = SrsJsonAny::loads(res)) == NULL) {
@ -503,9 +478,10 @@ srs_error_t SrsHttpHooks::discover_co_workers(string url, string& host, int& por
srs_freep(jr);
return srs_error_new(ERROR_OCLUSTER_DISCOVER, "response %s", res.c_str());
}
robj = jr->to_object();
robj_raw = jr->to_object();
}
SrsUniquePtr<SrsJsonObject> robj(robj_raw);
SrsJsonAny* prop = NULL;
if ((prop = robj->ensure_property_object("data")) == NULL) {
@ -540,9 +516,7 @@ srs_error_t SrsHttpHooks::on_forward_backend(string url, SrsRequest* req, std::v
SrsContextId cid = _srs_context->get_id();
SrsStatistic* stat = SrsStatistic::instance();
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
SrsUniquePtr<SrsJsonObject> obj(SrsJsonAny::object());
obj->set("action", SrsJsonAny::str("on_forward"));
obj->set("server_id", SrsJsonAny::str(stat->server_id().c_str()));
@ -566,11 +540,10 @@ srs_error_t SrsHttpHooks::on_forward_backend(string url, SrsRequest* req, std::v
}
// parse string res to json.
SrsJsonAny* info = SrsJsonAny::loads(res);
if (!info) {
SrsUniquePtr<SrsJsonAny> info(SrsJsonAny::loads(res));
if (!info.get()) {
return srs_error_new(ERROR_SYSTEM_FORWARD_LOOP, "load json from %s", res.c_str());
}
SrsAutoFree(SrsJsonAny, info);
// response error code in string.
if (!info->is_object()) {
@ -622,12 +595,12 @@ srs_error_t SrsHttpHooks::do_post(SrsHttpClient* hc, std::string url, std::strin
path += "?" + uri.get_query();
}
ISrsHttpMessage* msg = NULL;
if ((err = hc->post(path, req, &msg)) != srs_success) {
ISrsHttpMessage* msg_raw = NULL;
if ((err = hc->post(path, req, &msg_raw)) != srs_success) {
return srs_error_wrap(err, "http: client post");
}
SrsAutoFree(ISrsHttpMessage, msg);
SrsUniquePtr<ISrsHttpMessage> msg(msg_raw);
code = msg->status_code();
if ((err = msg->body_read_all(res)) != srs_success) {
return srs_error_wrap(err, "http: body read");
@ -644,12 +617,11 @@ srs_error_t SrsHttpHooks::do_post(SrsHttpClient* hc, std::string url, std::strin
}
// parse string res to json.
SrsJsonAny* info = SrsJsonAny::loads(res);
if (!info) {
SrsUniquePtr<SrsJsonAny> info(SrsJsonAny::loads(res));
if (!info.get()) {
return srs_error_new(ERROR_HTTP_DATA_INVALID, "http: not json %s", res.c_str());
}
SrsAutoFree(SrsJsonAny, info);
// response error code in string.
if (!info->is_object()) {
if (res == SRS_HTTP_RESPONSE_OK) {

40
trunk/src/app/srs_app_http_static.cpp
View file

@ -209,15 +209,14 @@ srs_error_t SrsHlsStream::serve_exists_session(ISrsHttpResponseWriter* w, ISrsHt
srs_error_t err = srs_success;
// Read m3u8 content.
SrsFileReader* fs = factory->create_file_reader();
SrsAutoFree(SrsFileReader, fs);
SrsUniquePtr<SrsFileReader> fs(factory->create_file_reader());
if ((err = fs->open(fullpath)) != srs_success) {
return srs_error_wrap(err, "open %s", fullpath.c_str());
}
string content;
if ((err = srs_ioutil_read_all(fs, content)) != srs_success) {
if ((err = srs_ioutil_read_all(fs.get(), content)) != srs_success) {
return srs_error_wrap(err, "read %s", fullpath.c_str());
}
@ -399,10 +398,9 @@ SrsVodStream::~SrsVodStream()
srs_error_t SrsVodStream::serve_flv_stream(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, string fullpath, int64_t offset)
{
srs_error_t err = srs_success;
SrsFileReader* fs = fs_factory->create_file_reader();
SrsAutoFree(SrsFileReader, fs);
SrsUniquePtr<SrsFileReader> fs(fs_factory->create_file_reader());
// open flv file
if ((err = fs->open(fullpath)) != srs_success) {
return srs_error_wrap(err, "open file");
@ -416,7 +414,7 @@ srs_error_t SrsVodStream::serve_flv_stream(ISrsHttpResponseWriter* w, ISrsHttpMe
SrsFlvVodStreamDecoder ffd;
// open fast decoder
if ((err = ffd.initialize(fs)) != srs_success) {
if ((err = ffd.initialize(fs.get())) != srs_success) {
return srs_error_wrap(err, "init ffd");
}
@ -429,9 +427,7 @@ srs_error_t SrsVodStream::serve_flv_stream(ISrsHttpResponseWriter* w, ISrsHttpMe
}
// save sequence header, send later
char* sh_data = NULL;
int sh_size = 0;
if (true) {
// send sequence header
int64_t start = 0;
@ -442,9 +438,9 @@ srs_error_t SrsVodStream::serve_flv_stream(ISrsHttpResponseWriter* w, ISrsHttpMe
return srs_error_new(ERROR_HTTP_REMUX_SEQUENCE_HEADER, "no sequence, size=%d", sh_size);
}
}
sh_data = new char[sh_size];
SrsAutoFreeA(char, sh_data);
if ((err = fs->read(sh_data, sh_size, NULL)) != srs_success) {
SrsUniquePtr<char[]> sh_data(new char[sh_size]);
if ((err = fs->read(sh_data.get(), sh_size, NULL)) != srs_success) {
return srs_error_wrap(err, "fs read");
}
@ -460,7 +456,7 @@ srs_error_t SrsVodStream::serve_flv_stream(ISrsHttpResponseWriter* w, ISrsHttpMe
if ((err = w->write(flv_header, sizeof(flv_header))) != srs_success) {
return srs_error_wrap(err, "write flv header");
}
if (sh_size > 0 && (err = w->write(sh_data, sh_size)) != srs_success) {
if (sh_size > 0 && (err = w->write(sh_data.get(), sh_size)) != srs_success) {
return srs_error_wrap(err, "write sequence");
}
@ -470,7 +466,7 @@ srs_error_t SrsVodStream::serve_flv_stream(ISrsHttpResponseWriter* w, ISrsHttpMe
}
// send data
if ((err = copy(w, fs, r, left)) != srs_success) {
if ((err = copy(w, fs.get(), r, left)) != srs_success) {
return srs_error_wrap(err, "read flv=%s size=%" PRId64, fullpath.c_str(), left);
}
@ -483,10 +479,9 @@ srs_error_t SrsVodStream::serve_mp4_stream(ISrsHttpResponseWriter* w, ISrsHttpMe
srs_assert(start >= 0);
srs_assert(end == -1 || end >= 0);
SrsFileReader* fs = fs_factory->create_file_reader();
SrsAutoFree(SrsFileReader, fs);
SrsUniquePtr<SrsFileReader> fs(fs_factory->create_file_reader());
// open flv file
if ((err = fs->open(fullpath)) != srs_success) {
return srs_error_wrap(err, "fs open");
@ -520,7 +515,7 @@ srs_error_t SrsVodStream::serve_mp4_stream(ISrsHttpResponseWriter* w, ISrsHttpMe
fs->seek2(start);
// send data
if ((err = copy(w, fs, r, left)) != srs_success) {
if ((err = copy(w, fs.get(), r, left)) != srs_success) {
return srs_error_wrap(err, "read mp4=%s size=%" PRId64, fullpath.c_str(), left);
}
@ -534,8 +529,7 @@ srs_error_t SrsVodStream::serve_m3u8_ctx(ISrsHttpResponseWriter * w, ISrsHttpMes
SrsHttpMessage* hr = dynamic_cast<SrsHttpMessage*>(r);
srs_assert(hr);
SrsRequest* req = hr->to_request(hr->host())->as_http();
SrsAutoFree(SrsRequest, req);
SrsUniquePtr<SrsRequest> req(hr->to_request(hr->host())->as_http());
// discovery vhost, resolve the vhost from config
SrsConfDirective* parsed_vhost = _srs_config->get_vhost(req->vhost);
@ -545,7 +539,7 @@ srs_error_t SrsVodStream::serve_m3u8_ctx(ISrsHttpResponseWriter * w, ISrsHttpMes
// Try to serve by HLS streaming.
bool served = false;
if ((err = hls_.serve_m3u8_ctx(w, r, fs_factory, fullpath, req, &served)) != srs_success) {
if ((err = hls_.serve_m3u8_ctx(w, r, fs_factory, fullpath, req.get(), &served)) != srs_success) {
return srs_error_wrap(err, "hls ctx");
}

100
trunk/src/app/srs_app_http_stream.cpp
View file

@ -129,18 +129,18 @@ srs_error_t SrsBufferCache::cycle()
// the stream cache will create consumer to cache stream,
// which will trigger to fetch stream from origin for edge.
SrsLiveConsumer* consumer = NULL;
SrsAutoFree(SrsLiveConsumer, consumer);
if ((err = live_source->create_consumer(consumer)) != srs_success) {
SrsLiveConsumer* consumer_raw = NULL;
if ((err = live_source->create_consumer(consumer_raw)) != srs_success) {
return srs_error_wrap(err, "create consumer");
}
if ((err = live_source->consumer_dumps(consumer, false, false, true)) != srs_success) {
SrsUniquePtr<SrsLiveConsumer> consumer(consumer_raw);
if ((err = live_source->consumer_dumps(consumer.get(), false, false, true)) != srs_success) {
return srs_error_wrap(err, "dumps consumer");
}
SrsPithyPrint* pprint = SrsPithyPrint::create_http_stream_cache();
SrsAutoFree(SrsPithyPrint, pprint);
SrsUniquePtr<SrsPithyPrint> pprint(SrsPithyPrint::create_http_stream_cache());
SrsMessageArray msgs(SRS_PERF_MW_MSGS);
// set the queue size, which used for max cache.
@ -647,7 +647,7 @@ srs_error_t SrsLiveStream::do_serve_http(ISrsHttpResponseWriter* w, ISrsHttpMess
srs_error_t err = srs_success;
string enc_desc;
ISrsBufferEncoder* enc = NULL;
ISrsBufferEncoder* enc_raw = NULL;
srs_assert(entry);
bool drop_if_not_match = _srs_config->get_vhost_http_remux_drop_if_not_match(req->vhost);
@ -658,29 +658,29 @@ srs_error_t SrsLiveStream::do_serve_http(ISrsHttpResponseWriter* w, ISrsHttpMess
if (srs_string_ends_with(entry->pattern, ".flv")) {
w->header()->set_content_type("video/x-flv");
enc_desc = "FLV";
enc = new SrsFlvStreamEncoder();
((SrsFlvStreamEncoder*)enc)->set_drop_if_not_match(drop_if_not_match);
((SrsFlvStreamEncoder*)enc)->set_has_audio(has_audio);
((SrsFlvStreamEncoder*)enc)->set_has_video(has_video);
((SrsFlvStreamEncoder*)enc)->set_guess_has_av(guess_has_av);
enc_raw = new SrsFlvStreamEncoder();
((SrsFlvStreamEncoder*)enc_raw)->set_drop_if_not_match(drop_if_not_match);
((SrsFlvStreamEncoder*)enc_raw)->set_has_audio(has_audio);
((SrsFlvStreamEncoder*)enc_raw)->set_has_video(has_video);
((SrsFlvStreamEncoder*)enc_raw)->set_guess_has_av(guess_has_av);
} else if (srs_string_ends_with(entry->pattern, ".aac")) {
w->header()->set_content_type("audio/x-aac");
enc_desc = "AAC";
enc = new SrsAacStreamEncoder();
enc_raw = new SrsAacStreamEncoder();
} else if (srs_string_ends_with(entry->pattern, ".mp3")) {
w->header()->set_content_type("audio/mpeg");
enc_desc = "MP3";
enc = new SrsMp3StreamEncoder();
enc_raw = new SrsMp3StreamEncoder();
} else if (srs_string_ends_with(entry->pattern, ".ts")) {
w->header()->set_content_type("video/MP2T");
enc_desc = "TS";
enc = new SrsTsStreamEncoder();
((SrsTsStreamEncoder*)enc)->set_has_audio(has_audio);
((SrsTsStreamEncoder*)enc)->set_has_video(has_video);
enc_raw = new SrsTsStreamEncoder();
((SrsTsStreamEncoder*)enc_raw)->set_has_audio(has_audio);
((SrsTsStreamEncoder*)enc_raw)->set_has_video(has_video);
} else {
return srs_error_new(ERROR_HTTP_LIVE_STREAM_EXT, "invalid pattern=%s", entry->pattern.c_str());
}
SrsAutoFree(ISrsBufferEncoder, enc);
SrsUniquePtr<ISrsBufferEncoder> enc(enc_raw);
// Enter chunked mode, because we didn't set the content-length.
w->write_header(SRS_CONSTS_HTTP_OK);
@ -691,18 +691,18 @@ srs_error_t SrsLiveStream::do_serve_http(ISrsHttpResponseWriter* w, ISrsHttpMess
}
// create consumer of souce, ignore gop cache, use the audio gop cache.
SrsLiveConsumer* consumer = NULL;
SrsAutoFree(SrsLiveConsumer, consumer);
if ((err = live_source->create_consumer(consumer)) != srs_success) {
SrsLiveConsumer* consumer_raw = NULL;
if ((err = live_source->create_consumer(consumer_raw)) != srs_success) {
return srs_error_wrap(err, "create consumer");
}
if ((err = live_source->consumer_dumps(consumer, true, true, !enc->has_cache())) != srs_success) {
SrsUniquePtr<SrsLiveConsumer> consumer(consumer_raw);
if ((err = live_source->consumer_dumps(consumer.get(), true, true, !enc->has_cache())) != srs_success) {
return srs_error_wrap(err, "dumps consumer");
}
SrsPithyPrint* pprint = SrsPithyPrint::create_http_stream();
SrsAutoFree(SrsPithyPrint, pprint);
SrsUniquePtr<SrsPithyPrint> pprint(SrsPithyPrint::create_http_stream());
SrsMessageArray msgs(SRS_PERF_MW_MSGS);
// Use receive thread to accept the close event to avoid FD leak.
@ -718,22 +718,21 @@ srs_error_t SrsLiveStream::do_serve_http(ISrsHttpResponseWriter* w, ISrsHttpMess
// if gop cache enabled for encoder, dump to consumer.
if (enc->has_cache()) {
if ((err = enc->dump_cache(consumer, live_source->jitter())) != srs_success) {
if ((err = enc->dump_cache(consumer.get(), live_source->jitter())) != srs_success) {
return srs_error_wrap(err, "encoder dump cache");
}
}
// Try to use fast flv encoder, remember that it maybe NULL.
SrsFlvStreamEncoder* ffe = dynamic_cast<SrsFlvStreamEncoder*>(enc);
SrsFlvStreamEncoder* ffe = dynamic_cast<SrsFlvStreamEncoder*>(enc.get());
// Note that the handler of hc now is hxc.
SrsHttpxConn* hxc = dynamic_cast<SrsHttpxConn*>(hc->handler());
srs_assert(hxc);
// Start a thread to receive all messages from client, then drop them.
SrsHttpRecvThread* trd = new SrsHttpRecvThread(hxc);
SrsAutoFree(SrsHttpRecvThread, trd);
SrsUniquePtr<SrsHttpRecvThread> trd(new SrsHttpRecvThread(hxc));
if ((err = trd->start()) != srs_success) {
return srs_error_wrap(err, "start recv thread");
}
@ -777,7 +776,7 @@ srs_error_t SrsLiveStream::do_serve_http(ISrsHttpResponseWriter* w, ISrsHttpMess
if (ffe) {
err = ffe->write_tags(msgs.msgs, count);
} else {
err = streaming_send_messages(enc, msgs.msgs, count);
err = streaming_send_messages(enc.get(), msgs.msgs, count);
}
// TODO: FIXME: Update the stat.
@ -809,9 +808,8 @@ srs_error_t SrsLiveStream::http_hooks_on_play(ISrsHttpMessage* r)
// Create request to report for the specified connection.
SrsHttpMessage* hr = dynamic_cast<SrsHttpMessage*>(r);
SrsRequest* nreq = hr->to_request(req->vhost);
SrsAutoFree(SrsRequest, nreq);
SrsUniquePtr<SrsRequest> nreq(hr->to_request(req->vhost));
// the http hooks will cause context switch,
// so we must copy all hooks for the on_connect may freed.
// @see https://github.com/ossrs/srs/issues/475
@ -829,7 +827,7 @@ srs_error_t SrsLiveStream::http_hooks_on_play(ISrsHttpMessage* r)
for (int i = 0; i < (int)hooks.size(); i++) {
std::string url = hooks.at(i);
if ((err = SrsHttpHooks::on_play(url, nreq)) != srs_success) {
if ((err = SrsHttpHooks::on_play(url, nreq.get())) != srs_success) {
return srs_error_wrap(err, "http on_play %s", url.c_str());
}
}
@ -845,9 +843,8 @@ void SrsLiveStream::http_hooks_on_stop(ISrsHttpMessage* r)
// Create request to report for the specified connection.
SrsHttpMessage* hr = dynamic_cast<SrsHttpMessage*>(r);
SrsRequest* nreq = hr->to_request(req->vhost);
SrsAutoFree(SrsRequest, nreq);
SrsUniquePtr<SrsRequest> nreq(hr->to_request(req->vhost));
// the http hooks will cause context switch,
// so we must copy all hooks for the on_connect may freed.
// @see https://github.com/ossrs/srs/issues/475
@ -866,7 +863,7 @@ void SrsLiveStream::http_hooks_on_stop(ISrsHttpMessage* r)
for (int i = 0; i < (int)hooks.size(); i++) {
std::string url = hooks.at(i);
SrsHttpHooks::on_stop(url, nreq);
SrsHttpHooks::on_stop(url, nreq.get());
}
return;
@ -1063,15 +1060,11 @@ void SrsHttpStreamServer::http_unmount(SrsRequest* r)
}
// Free all HTTP resources.
SrsLiveEntry* entry = it->second;
SrsAutoFree(SrsLiveEntry, entry);
SrsUniquePtr<SrsLiveEntry> entry(it->second);
streamHandlers.erase(it);
SrsLiveStream* stream = entry->stream;
SrsAutoFree(SrsLiveStream, stream);
SrsBufferCache* cache = entry->cache;
SrsAutoFree(SrsBufferCache, cache);
SrsUniquePtr<SrsLiveStream> stream(entry->stream);
SrsUniquePtr<SrsBufferCache> cache(entry->cache);
// Notify cache and stream to stop.
if (stream->entry) stream->entry->enabled = false;
@ -1088,7 +1081,7 @@ void SrsHttpStreamServer::http_unmount(SrsRequest* r)
// Unmount the HTTP handler, which will free the entry. Note that we must free it after cache and
// stream stopped for it uses it.
mux.unhandle(entry->mount, stream);
mux.unhandle(entry->mount, stream.get());
srs_trace("http: unmount flv stream for sid=%s, i=%d", sid.c_str(), i);
}
@ -1170,9 +1163,8 @@ srs_error_t SrsHttpStreamServer::hijack(ISrsHttpMessage* request, ISrsHttpHandle
srs_assert(hreq);
// hijack for entry.
SrsRequest* r = hreq->to_request(vhost->arg0());
SrsAutoFree(SrsRequest, r);
SrsUniquePtr<SrsRequest> r(hreq->to_request(vhost->arg0()));
std::string sid = r->get_stream_url();
// check whether the http remux is enabled,
// for example, user disable the http flv then reload.
@ -1189,7 +1181,7 @@ srs_error_t SrsHttpStreamServer::hijack(ISrsHttpMessage* request, ISrsHttpHandle
}
SrsSharedPtr<SrsLiveSource> live_source;
if ((err = _srs_sources->fetch_or_create(r, server, live_source)) != srs_success) {
if ((err = _srs_sources->fetch_or_create(r.get(), server, live_source)) != srs_success) {
return srs_error_wrap(err, "source create");
}
srs_assert(live_source.get() != NULL);
@ -1200,7 +1192,7 @@ srs_error_t SrsHttpStreamServer::hijack(ISrsHttpMessage* request, ISrsHttpHandle
live_source->set_gop_cache_max_frames(gcmf);
// create http streaming handler.
if ((err = http_mount(r)) != srs_success) {
if ((err = http_mount(r.get())) != srs_success) {
return srs_error_wrap(err, "http mount");
}

12
trunk/src/app/srs_app_latest_version.cpp
View file

@ -266,11 +266,12 @@ srs_error_t SrsLatestVersion::query_latest_version(string& url)
path += "?";
path += uri.get_query();
ISrsHttpMessage* msg = NULL;
if ((err = http.get(path, "", &msg)) != srs_success) {
ISrsHttpMessage* msg_raw = NULL;
if ((err = http.get(path, "", &msg_raw)) != srs_success) {
return err;
}
SrsAutoFree(ISrsHttpMessage, msg);
SrsUniquePtr<ISrsHttpMessage> msg(msg_raw);
string res;
int code = msg->status_code();
@ -288,11 +289,10 @@ srs_error_t SrsLatestVersion::query_latest_version(string& url)
}
// Response in json object.
SrsJsonAny* jres = SrsJsonAny::loads((char*)res.c_str());
if (!jres || !jres->is_object()) {
SrsUniquePtr<SrsJsonAny> jres(SrsJsonAny::loads((char*)res.c_str()));
if (!jres.get() || !jres->is_object()) {
return srs_error_new(ERROR_HTTP_DATA_INVALID, "invalid response %s", res.c_str());
}
SrsAutoFree(SrsJsonAny, jres);
SrsJsonObject* obj = jres->to_object();
SrsJsonAny* prop = NULL;

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

@ -688,8 +688,7 @@ srs_error_t SrsUdpMuxListener::cycle()
{
srs_error_t err = srs_success;
SrsPithyPrint* pprint = SrsPithyPrint::create_rtc_recv(srs_netfd_fileno(lfd));
SrsAutoFree(SrsPithyPrint, pprint);
SrsUniquePtr<SrsPithyPrint> pprint(SrsPithyPrint::create_rtc_recv(srs_netfd_fileno(lfd)));
uint64_t nn_msgs = 0;
uint64_t nn_msgs_stage = 0;
@ -697,8 +696,7 @@ srs_error_t SrsUdpMuxListener::cycle()
uint64_t nn_loop = 0;
srs_utime_t time_last = srs_get_system_time();
SrsErrorPithyPrint* pp_pkt_handler_err = new SrsErrorPithyPrint();
SrsAutoFree(SrsErrorPithyPrint, pp_pkt_handler_err);
SrsUniquePtr<SrsErrorPithyPrint> pp_pkt_handler_err(new SrsErrorPithyPrint());
set_socket_buffer();

15
trunk/src/app/srs_app_mpegts_udp.cpp
View file

@ -236,13 +236,12 @@ srs_error_t SrsMpegtsOverUdp::on_udp_bytes(string host, int port, char* buf, int
}
buffer->erase(buffer->length());
int nb_fbuf = fr.filesize();
char* fbuf = new char[nb_fbuf];
SrsAutoFreeA(char, fbuf);
if ((err = fr.read(fbuf, nb_fbuf, NULL)) != srs_success) {
SrsUniquePtr<char[]> fbuf(new char[nb_fbuf]);
if ((err = fr.read(fbuf.get(), nb_fbuf, NULL)) != srs_success) {
return srs_error_wrap(err, "read data");
}
fr.close();
buffer->append(fbuf, nb_fbuf);
buffer->append(fbuf.get(), nb_fbuf);
#endif
// find the sync byte of mpegts.
@ -268,12 +267,10 @@ srs_error_t SrsMpegtsOverUdp::on_udp_bytes(string host, int port, char* buf, int
int nb_packet = buffer->length() / SRS_TS_PACKET_SIZE;
for (int i = 0; i < nb_packet; i++) {
char* p = buffer->bytes() + (i * SRS_TS_PACKET_SIZE);
SrsBuffer* stream = new SrsBuffer(p, SRS_TS_PACKET_SIZE);
SrsAutoFree(SrsBuffer, stream);
SrsUniquePtr<SrsBuffer> stream(new SrsBuffer(p, SRS_TS_PACKET_SIZE));
// process each ts packet
if ((err = context->decode(stream, this)) != srs_success) {
if ((err = context->decode(stream.get(), this)) != srs_success) {
srs_info("parse ts packet err=%s", srs_error_desc(err).c_str());
srs_error_reset(err);
continue;

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

@ -94,8 +94,7 @@ public:
// if there is 1client, it will print every 3s.
// if there is 10clients, random select one to print every 3s.
// Usage:
// SrsPithyPrint* pprint = SrsPithyPrint::create_rtmp_play();
// SrsAutoFree(SrsPithyPrint, pprint);
// SrsUniquePtr<SrsPithyPrint> pprint(SrsPithyPrint::create_rtmp_play());
// while (true) {
// pprint->elapse();
// if (pprint->can_print()) {

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

@ -577,10 +577,8 @@ srs_error_t SrsHttpRecvThread::cycle()
srs_error_t err = srs_success;
while ((err = trd->pull()) == srs_success) {
ISrsHttpMessage* req = NULL;
SrsAutoFree(ISrsHttpMessage, req);
if ((err = conn->pop_message(&req)) != srs_success) {
// Ignore any received messages.
if ((err = conn->pop_message(NULL)) != srs_success) {
return srs_error_wrap(err, "pop message");
}
}

27
trunk/src/app/srs_app_rtc_api.cpp
View file

@ -53,10 +53,9 @@ srs_error_t SrsGoApiRtcPlay::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
{
srs_error_t err = srs_success;
SrsJsonObject* res = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, res);
SrsUniquePtr<SrsJsonObject> res(SrsJsonAny::object());
if ((err = do_serve_http(w, r, res)) != srs_success) {
if ((err = do_serve_http(w, r, res.get())) != srs_success) {
srs_warn("RTC error %s", srs_error_desc(err).c_str()); srs_freep(err);
return srs_api_response_code(w, r, SRS_CONSTS_HTTP_BadRequest);
}
@ -73,8 +72,7 @@ srs_error_t SrsGoApiRtcPlay::do_serve_http(ISrsHttpResponseWriter* w, ISrsHttpMe
hdr->set("Connection", "Close");
// Parse req, the request json object, from body.
SrsJsonObject* req = NULL;
SrsAutoFree(SrsJsonObject, req);
SrsJsonObject* req_raw = NULL;
if (true) {
string req_json;
if ((err = r->body_read_all(req_json)) != srs_success) {
@ -86,8 +84,9 @@ srs_error_t SrsGoApiRtcPlay::do_serve_http(ISrsHttpResponseWriter* w, ISrsHttpMe
return srs_error_new(ERROR_RTC_API_BODY, "invalid body %s", req_json.c_str());
}
req = json->to_object();
req_raw = json->to_object();
}
SrsUniquePtr<SrsJsonObject> req(req_raw);
// Fetch params from req object.
SrsJsonAny* prop = NULL;
@ -351,10 +350,9 @@ srs_error_t SrsGoApiRtcPublish::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMe
{
srs_error_t err = srs_success;
SrsJsonObject* res = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, res);
SrsUniquePtr<SrsJsonObject> res(SrsJsonAny::object());
if ((err = do_serve_http(w, r, res)) != srs_success) {
if ((err = do_serve_http(w, r, res.get())) != srs_success) {
srs_warn("RTC error %s", srs_error_desc(err).c_str()); srs_freep(err);
return srs_api_response_code(w, r, SRS_CONSTS_HTTP_BadRequest);
}
@ -370,8 +368,7 @@ srs_error_t SrsGoApiRtcPublish::do_serve_http(ISrsHttpResponseWriter* w, ISrsHtt
w->header()->set("Connection", "Close");
// Parse req, the request json object, from body.
SrsJsonObject* req = NULL;
SrsAutoFree(SrsJsonObject, req);
SrsJsonObject* req_raw = NULL;
if (true) {
string req_json;
if ((err = r->body_read_all(req_json)) != srs_success) {
@ -383,8 +380,9 @@ srs_error_t SrsGoApiRtcPublish::do_serve_http(ISrsHttpResponseWriter* w, ISrsHtt
return srs_error_new(ERROR_RTC_API_BODY, "invalid body %s", req_json.c_str());
}
req = json->to_object();
req_raw = json->to_object();
}
SrsUniquePtr<SrsJsonObject> req(req_raw);
// Fetch params from req object.
SrsJsonAny* prop = NULL;
@ -775,12 +773,11 @@ srs_error_t SrsGoApiRtcNACK::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
{
srs_error_t err = srs_success;
SrsJsonObject* res = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, res);
SrsUniquePtr<SrsJsonObject> res(SrsJsonAny::object());
res->set("code", SrsJsonAny::integer(ERROR_SUCCESS));
if ((err = do_serve_http(w, r, res)) != srs_success) {
if ((err = do_serve_http(w, r, res.get())) != srs_success) {
srs_warn("RTC: NACK err %s", srs_error_desc(err).c_str());
res->set("code", SrsJsonAny::integer(srs_error_code(err)));
srs_freep(err);

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

@ -644,17 +644,18 @@ srs_error_t SrsRtcPlayStream::cycle()
SrsSharedPtr<SrsRtcSource>& source = source_;
srs_assert(source.get());
SrsRtcConsumer* consumer = NULL;
SrsAutoFree(SrsRtcConsumer, consumer);
if ((err = source->create_consumer(consumer)) != srs_success) {
SrsRtcConsumer* consumer_raw = NULL;
if ((err = source->create_consumer(consumer_raw)) != srs_success) {
return srs_error_wrap(err, "create consumer, source=%s", req_->get_stream_url().c_str());
}
srs_assert(consumer);
srs_assert(consumer_raw);
SrsUniquePtr<SrsRtcConsumer> consumer(consumer_raw);
consumer->set_handler(this);
// TODO: FIXME: Dumps the SPS/PPS from gop cache, without other frames.
if ((err = source->consumer_dumps(consumer)) != srs_success) {
if ((err = source->consumer_dumps(consumer.get())) != srs_success) {
return srs_error_wrap(err, "dumps consumer, url=%s", req_->get_stream_url().c_str());
}
@ -666,8 +667,7 @@ srs_error_t SrsRtcPlayStream::cycle()
srs_trace("RTC: start play url=%s, source_id=%s/%s, realtime=%d, mw_msgs=%d", req_->get_stream_url().c_str(),
cid.c_str(), source->pre_source_id().c_str(), realtime, mw_msgs);
SrsErrorPithyPrint* epp = new SrsErrorPithyPrint();
SrsAutoFree(SrsErrorPithyPrint, epp);
SrsUniquePtr<SrsErrorPithyPrint> epp(new SrsErrorPithyPrint());
while (true) {
if ((err = trd_->pull()) != srs_success) {
@ -1541,13 +1541,12 @@ srs_error_t SrsRtcPublishStream::send_periodic_twcc()
// limit the max count=1024 to avoid dead loop.
for (int i = 0; i < 1024 && rtcp_twcc_.need_feedback(); ++i) {
char pkt[kMaxUDPDataSize];
SrsBuffer *buffer = new SrsBuffer(pkt, sizeof(pkt));
SrsAutoFree(SrsBuffer, buffer);
SrsUniquePtr<SrsBuffer> buffer(new SrsBuffer(pkt, sizeof(pkt)));
rtcp_twcc_.set_feedback_count(twcc_fb_count_);
twcc_fb_count_++;
if((err = rtcp_twcc_.encode(buffer)) != srs_success) {
if((err = rtcp_twcc_.encode(buffer.get())) != srs_success) {
return srs_error_wrap(err, "encode, count=%u", twcc_fb_count_);
}
@ -1937,15 +1936,14 @@ srs_error_t SrsRtcConnection::add_publisher(SrsRtcUserConfig* ruc, SrsSdp& local
SrsRequest* req = ruc->req_;
SrsRtcSourceDescription* stream_desc = new SrsRtcSourceDescription();
SrsAutoFree(SrsRtcSourceDescription, stream_desc);
SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
// TODO: FIXME: Change to api of stream desc.
if ((err = negotiate_publish_capability(ruc, stream_desc)) != srs_success) {
if ((err = negotiate_publish_capability(ruc, stream_desc.get())) != srs_success) {
return srs_error_wrap(err, "publish negotiate, offer=%s", srs_string_replace(ruc->remote_sdp_str_.c_str(), "\r\n", "\\r\\n").c_str());
}
if ((err = generate_publish_local_sdp(req, local_sdp, stream_desc, ruc->remote_sdp_.is_unified(), ruc->audio_before_video_)) != srs_success) {
if ((err = generate_publish_local_sdp(req, local_sdp, stream_desc.get(), ruc->remote_sdp_.is_unified(), ruc->audio_before_video_)) != srs_success) {
return srs_error_wrap(err, "generate local sdp");
}
@ -1962,10 +1960,10 @@ srs_error_t SrsRtcConnection::add_publisher(SrsRtcUserConfig* ruc, SrsSdp& local
source->set_stream_created();
// Apply the SDP to source.
source->set_stream_desc(stream_desc);
source->set_stream_desc(stream_desc.get());
// TODO: FIXME: What happends when error?
if ((err = create_publisher(req, stream_desc)) != srs_success) {
if ((err = create_publisher(req, stream_desc.get())) != srs_success) {
return srs_error_wrap(err, "create publish");
}
@ -1988,8 +1986,7 @@ srs_error_t SrsRtcConnection::add_player(SrsRtcUserConfig* ruc, SrsSdp& local_sd
return srs_error_new(ERROR_RTC_SDP_EXCHANGE, "no play relations");
}
SrsRtcSourceDescription* stream_desc = new SrsRtcSourceDescription();
SrsAutoFree(SrsRtcSourceDescription, stream_desc);
SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
std::map<uint32_t, SrsRtcTrackDescription*>::iterator it = play_sub_relations.begin();
while (it != play_sub_relations.end()) {
SrsRtcTrackDescription* track_desc = it->second;
@ -2005,7 +2002,7 @@ srs_error_t SrsRtcConnection::add_player(SrsRtcUserConfig* ruc, SrsSdp& local_sd
++it;
}
if ((err = generate_play_local_sdp(req, local_sdp, stream_desc, ruc->remote_sdp_.is_unified(), ruc->audio_before_video_)) != srs_success) {
if ((err = generate_play_local_sdp(req, local_sdp, stream_desc.get(), ruc->remote_sdp_.is_unified(), ruc->audio_before_video_)) != srs_success) {
return srs_error_wrap(err, "generate local sdp");
}
@ -2046,20 +2043,19 @@ srs_error_t SrsRtcConnection::on_rtcp(char* unprotected_buf, int nb_unprotected_
{
srs_error_t err = srs_success;
SrsBuffer* buffer = new SrsBuffer(unprotected_buf, nb_unprotected_buf);
SrsAutoFree(SrsBuffer, buffer);
SrsUniquePtr<SrsBuffer> buffer(new SrsBuffer(unprotected_buf, nb_unprotected_buf));
SrsRtcpCompound rtcp_compound;
if(srs_success != (err = rtcp_compound.decode(buffer))) {
if(srs_success != (err = rtcp_compound.decode(buffer.get()))) {
return srs_error_wrap(err, "decode rtcp plaintext=%u, bytes=[%s], at=%s", nb_unprotected_buf,
srs_string_dumps_hex(unprotected_buf, nb_unprotected_buf, 8).c_str(),
srs_string_dumps_hex(buffer->head(), buffer->left(), 8).c_str());
}
SrsRtcpCommon* rtcp = NULL;
while(NULL != (rtcp = rtcp_compound.get_next_rtcp())) {
err = dispatch_rtcp(rtcp);
SrsAutoFree(SrsRtcpCommon, rtcp);
SrsRtcpCommon* rtcp_raw = NULL;
while(NULL != (rtcp_raw = rtcp_compound.get_next_rtcp())) {
err = dispatch_rtcp(rtcp_raw);
SrsUniquePtr<SrsRtcpCommon> rtcp(rtcp_raw);
if(srs_success != err) {
return srs_error_wrap(err, "plaintext=%u, bytes=[%s], rtcp=(%u,%u,%u,%u)", nb_unprotected_buf,
@ -2626,8 +2622,7 @@ srs_error_t SrsRtcConnection::negotiate_publish_capability(SrsRtcUserConfig* ruc
if (remote_media_desc.is_video()) nn_any_video_parsed++;
SrsRtcTrackDescription* track_desc = new SrsRtcTrackDescription();
SrsAutoFree(SrsRtcTrackDescription, track_desc);
SrsUniquePtr<SrsRtcTrackDescription> track_desc(new SrsRtcTrackDescription());
track_desc->set_direction("recvonly");
track_desc->set_mid(remote_media_desc.mid_);

23
trunk/src/app/srs_app_rtc_dtls.cpp
View file

@ -329,13 +329,12 @@ srs_error_t SrsDtlsCertificate::initialize()
// TODO: FIXME: Unused variable.
/*int r = */X509_digest(dtls_cert, EVP_sha256(), md, &n);
char* fp = new char[3 * n];
SrsAutoFreeA(char, fp);
char *p = fp;
SrsUniquePtr<char[]> fp(new char[3 * n]);
char* p = fp.get();
for (unsigned int i = 0; i < n; i++, ++p) {
int nb = snprintf(p, 3, "%02X", md[i]);
srs_assert(nb > 0 && nb < (3 * n - (p - fp)));
srs_assert(nb > 0 && nb < (3 * n - (p - fp.get())));
p += nb;
if(i < (n-1)) {
@ -345,7 +344,7 @@ srs_error_t SrsDtlsCertificate::initialize()
}
}
fingerprint.assign(fp, strlen(fp));
fingerprint.assign(fp.get(), strlen(fp.get()));
srs_trace("fingerprint=%s", fingerprint.c_str());
}
@ -985,10 +984,9 @@ srs_error_t SrsSRTP::initialize(string recv_key, std::string send_key)
// init recv context
policy.ssrc.type = ssrc_any_inbound;
uint8_t *rkey = new uint8_t[recv_key.size()];
SrsAutoFreeA(uint8_t, rkey);
memcpy(rkey, recv_key.data(), recv_key.size());
policy.key = rkey;
SrsUniquePtr<uint8_t[]> rkey(new uint8_t[recv_key.size()]);
memcpy(rkey.get(), recv_key.data(), recv_key.size());
policy.key = rkey.get();
srtp_err_status_t r0 = srtp_err_status_ok;
if ((r0 = srtp_create(&recv_ctx_, &policy)) != srtp_err_status_ok) {
@ -996,10 +994,9 @@ srs_error_t SrsSRTP::initialize(string recv_key, std::string send_key)
}
policy.ssrc.type = ssrc_any_outbound;
uint8_t *skey = new uint8_t[send_key.size()];
SrsAutoFreeA(uint8_t, skey);
memcpy(skey, send_key.data(), send_key.size());
policy.key = skey;
SrsUniquePtr<uint8_t[]> skey(new uint8_t[send_key.size()]);
memcpy(skey.get(), send_key.data(), send_key.size());
policy.key = skey.get();
if ((r0 = srtp_create(&send_ctx_, &policy)) != srtp_err_status_ok) {
return srs_error_new(ERROR_RTC_SRTP_INIT, "srtp create r0=%u", r0);

10
trunk/src/app/srs_app_rtc_network.cpp
View file

@ -391,8 +391,7 @@ srs_error_t SrsRtcUdpNetwork::on_binding_request(SrsStunPacket* r, string ice_pw
SrsStunPacket stun_binding_response;
char buf[kRtpPacketSize];
SrsBuffer* stream = new SrsBuffer(buf, sizeof(buf));
SrsAutoFree(SrsBuffer, stream);
SrsUniquePtr<SrsBuffer> stream(new SrsBuffer(buf, sizeof(buf)));
stun_binding_response.set_message_type(BindingResponse);
stun_binding_response.set_local_ufrag(r->get_remote_ufrag());
@ -402,7 +401,7 @@ srs_error_t SrsRtcUdpNetwork::on_binding_request(SrsStunPacket* r, string ice_pw
stun_binding_response.set_mapped_address(be32toh(inet_addr(get_peer_ip().c_str())));
stun_binding_response.set_mapped_port(get_peer_port());
if ((err = stun_binding_response.encode(ice_pwd, stream)) != srs_success) {
if ((err = stun_binding_response.encode(ice_pwd, stream.get())) != srs_success) {
return srs_error_wrap(err, "stun binding response encode failed");
}
@ -520,8 +519,7 @@ srs_error_t SrsRtcTcpNetwork::on_binding_request(SrsStunPacket* r, std::string i
SrsStunPacket stun_binding_response;
char buf[kRtpPacketSize];
SrsBuffer* stream = new SrsBuffer(buf, sizeof(buf));
SrsAutoFree(SrsBuffer, stream);
SrsUniquePtr<SrsBuffer> stream(new SrsBuffer(buf, sizeof(buf)));
stun_binding_response.set_message_type(BindingResponse);
stun_binding_response.set_local_ufrag(r->get_remote_ufrag());
@ -531,7 +529,7 @@ srs_error_t SrsRtcTcpNetwork::on_binding_request(SrsStunPacket* r, std::string i
stun_binding_response.set_mapped_address(be32toh(inet_addr(get_peer_ip().c_str())));
stun_binding_response.set_mapped_port(get_peer_port());
if ((err = stun_binding_response.encode(ice_pwd, stream)) != srs_success) {
if ((err = stun_binding_response.encode(ice_pwd, stream.get())) != srs_success) {
return srs_error_wrap(err, "stun binding response encode failed");
}

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

@ -29,6 +29,7 @@
#include <srs_app_log.hpp>
#include <srs_app_threads.hpp>
#include <srs_app_statistic.hpp>
#include <srs_core_deprecated.hpp>
#ifdef SRS_FFMPEG_FIT
#include <srs_app_rtc_codec.hpp>
@ -449,8 +450,7 @@ void SrsRtcSource::init_for_play_before_publishing()
return;
}
SrsRtcSourceDescription* stream_desc = new SrsRtcSourceDescription();
SrsAutoFree(SrsRtcSourceDescription, stream_desc);
SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
// audio track description
if (true) {
@ -485,7 +485,7 @@ void SrsRtcSource::init_for_play_before_publishing()
video_payload->set_h264_param_desc("level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f");
}
set_stream_desc(stream_desc);
set_stream_desc(stream_desc.get());
}
void SrsRtcSource::update_auth(SrsRequest* r)
@ -1006,16 +1006,14 @@ srs_error_t SrsRtcRtpBuilder::transcode(SrsAudioFrame* audio)
for (std::vector<SrsAudioFrame*>::iterator it = out_audios.begin(); it != out_audios.end(); ++it) {
SrsAudioFrame* out_audio = *it;
SrsUniquePtr<SrsRtpPacket> pkt(new SrsRtpPacket());
SrsRtpPacket* pkt = new SrsRtpPacket();
SrsAutoFree(SrsRtpPacket, pkt);
if ((err = package_opus(out_audio, pkt)) != srs_success) {
if ((err = package_opus(out_audio, pkt.get())) != srs_success) {
err = srs_error_wrap(err, "package opus");
break;
}
if ((err = bridge_->on_rtp(pkt)) != srs_success) {
if ((err = bridge_->on_rtp(pkt.get())) != srs_success) {
err = srs_error_wrap(err, "consume opus");
break;
}
@ -1083,14 +1081,13 @@ srs_error_t SrsRtcRtpBuilder::on_video(SrsSharedPtrMessage* msg)
// Well, for each IDR, we append a SPS/PPS before it, which is packaged in STAP-A.
if (has_idr) {
SrsRtpPacket* pkt = new SrsRtpPacket();
SrsAutoFree(SrsRtpPacket, pkt);
SrsUniquePtr<SrsRtpPacket> pkt(new SrsRtpPacket());
if ((err = package_stap_a(msg, pkt)) != srs_success) {
if ((err = package_stap_a(msg, pkt.get())) != srs_success) {
return srs_error_wrap(err, "package stap-a");
}
if ((err = bridge_->on_rtp(pkt)) != srs_success) {
if ((err = bridge_->on_rtp(pkt.get())) != srs_success) {
return srs_error_wrap(err, "consume sps/pps");
}
}
@ -1231,7 +1228,7 @@ srs_error_t SrsRtcRtpBuilder::package_nalus(SrsSharedPtrMessage* msg, const vect
{
srs_error_t err = srs_success;
SrsRtpRawNALUs* raw = new SrsRtpRawNALUs();
SrsRtpRawNALUs* raw_raw = new SrsRtpRawNALUs();
SrsAvcNaluType first_nalu_type = SrsAvcNaluTypeReserved;
for (int i = 0; i < (int)samples.size(); i++) {
@ -1245,13 +1242,13 @@ srs_error_t SrsRtcRtpBuilder::package_nalus(SrsSharedPtrMessage* msg, const vect
first_nalu_type = SrsAvcNaluType((uint8_t)(sample->bytes[0] & kNalTypeMask));
}
raw->push_back(sample->copy());
raw_raw->push_back(sample->copy());
}
// Ignore empty.
int nn_bytes = raw->nb_bytes();
int nn_bytes = raw_raw->nb_bytes();
if (nn_bytes <= 0) {
srs_freep(raw);
srs_freep(raw_raw);
return err;
}
@ -1266,12 +1263,12 @@ srs_error_t SrsRtcRtpBuilder::package_nalus(SrsSharedPtrMessage* msg, const vect
pkt->nalu_type = (SrsAvcNaluType)first_nalu_type;
pkt->header.set_sequence(video_sequence++);
pkt->header.set_timestamp(msg->timestamp * 90);
pkt->set_payload(raw, SrsRtspPacketPayloadTypeNALU);
pkt->set_payload(raw_raw, SrsRtspPacketPayloadTypeNALU);
pkt->wrap(msg);
} else {
// We must free it, should never use RTP packets to free it,
// because more than one RTP packet will refer to it.
SrsAutoFree(SrsRtpRawNALUs, raw);
SrsUniquePtr<SrsRtpRawNALUs> raw(raw_raw);
// Package NALUs in FU-A RTP packets.
int fu_payload_size = kRtpMaxPayloadSize;
@ -1642,13 +1639,13 @@ srs_error_t SrsRtcFrameBuilder::packet_video_key_frame(SrsRtpPacket* pkt)
}
// Reset SPS/PPS cache, ensuring that the next SPS/PPS will be handled when both are received.
// Note that we should use SrsAutoFree to set the ptr to NULL.
SrsAutoFree(SrsRtpPacket, obs_whip_sps_);
SrsAutoFree(SrsRtpPacket, obs_whip_pps_);
// h264 raw to h264 packet.
std::string sh;
SrsRawH264Stream* avc = new SrsRawH264Stream();
SrsAutoFree(SrsRawH264Stream, avc);
SrsUniquePtr<SrsRawH264Stream> avc(new SrsRawH264Stream());
if ((err = avc->mux_sequence_header(string(sps->bytes, sps->size), string(pps->bytes, pps->size), sh)) != srs_success) {
return srs_error_wrap(err, "mux sequence header");

99
trunk/src/app/srs_app_rtmp_conn.cpp
View file

@ -755,25 +755,26 @@ srs_error_t SrsRtmpConn::playing(SrsSharedPtr<SrsLiveSource> source)
set_sock_options();
// Create a consumer of source.
SrsLiveConsumer* consumer = NULL;
SrsAutoFree(SrsLiveConsumer, consumer);
if ((err = source->create_consumer(consumer)) != srs_success) {
SrsLiveConsumer* consumer_raw = NULL;
if ((err = source->create_consumer(consumer_raw)) != srs_success) {
return srs_error_wrap(err, "rtmp: create consumer");
}
if ((err = source->consumer_dumps(consumer)) != srs_success) {
SrsUniquePtr<SrsLiveConsumer> consumer(consumer_raw);
if ((err = source->consumer_dumps(consumer.get())) != srs_success) {
return srs_error_wrap(err, "rtmp: dumps consumer");
}
// Use receiving thread to receive packets from peer.
SrsQueueRecvThread trd(consumer, rtmp, SRS_PERF_MW_SLEEP, _srs_context->get_id());
SrsQueueRecvThread trd(consumer.get(), rtmp, SRS_PERF_MW_SLEEP, _srs_context->get_id());
if ((err = trd.start()) != srs_success) {
return srs_error_wrap(err, "rtmp: start receive thread");
}
// Deliver packets to peer.
wakable = consumer;
err = do_playing(source, consumer, &trd);
wakable = consumer.get();
err = do_playing(source, consumer.get(), &trd);
wakable = NULL;
trd.stop();
@ -795,9 +796,8 @@ srs_error_t SrsRtmpConn::do_playing(SrsSharedPtr<SrsLiveSource> source, SrsLiveC
srs_assert(consumer);
// initialize other components
SrsPithyPrint* pprint = SrsPithyPrint::create_rtmp_play();
SrsAutoFree(SrsPithyPrint, pprint);
SrsUniquePtr<SrsPithyPrint> pprint(SrsPithyPrint::create_rtmp_play());
SrsMessageArray msgs(SRS_PERF_MW_MSGS);
bool user_specified_duration_to_stop = (req->duration > 0);
int64_t starttime = -1;
@ -816,9 +816,8 @@ srs_error_t SrsRtmpConn::do_playing(SrsSharedPtr<SrsLiveSource> source, SrsLiveC
srsu2msi(send_min_interval), srsu2msi(mw_sleep), mw_msgs, realtime, tcp_nodelay);
#ifdef SRS_APM
ISrsApmSpan* span = _srs_apm->span("play-cycle")->set_kind(SrsApmKindProducer)->as_child(span_client_)
->attr("realtime", srs_fmt("%d", realtime))->end();
SrsAutoFree(ISrsApmSpan, span);
SrsUniquePtr<ISrsApmSpan> span(_srs_apm->span("play-cycle")->set_kind(SrsApmKindProducer)->as_child(span_client_)
->attr("realtime", srs_fmt("%d", realtime))->end());
#endif
while (true) {
@ -866,7 +865,7 @@ srs_error_t SrsRtmpConn::do_playing(SrsSharedPtr<SrsLiveSource> source, SrsLiveC
#ifdef SRS_APM
// TODO: Do not use pithy print for frame span.
ISrsApmSpan* sample = _srs_apm->span("play-frame")->set_kind(SrsApmKindConsumer)->as_child(span)
ISrsApmSpan* sample = _srs_apm->span("play-frame")->set_kind(SrsApmKindConsumer)->as_child(span.get())
->attr("msgs", srs_fmt("%d", count))->attr("kbps", srs_fmt("%d", kbps->get_send_kbps_30s()));
srs_freep(sample);
#endif
@ -974,8 +973,7 @@ srs_error_t SrsRtmpConn::do_publishing(SrsSharedPtr<SrsLiveSource> source, SrsPu
srs_error_t err = srs_success;
SrsRequest* req = info->req;
SrsPithyPrint* pprint = SrsPithyPrint::create_rtmp_publish();
SrsAutoFree(SrsPithyPrint, pprint);
SrsUniquePtr<SrsPithyPrint> pprint(SrsPithyPrint::create_rtmp_publish());
// start isolate recv thread.
// TODO: FIXME: Pass the callback here.
@ -998,9 +996,8 @@ srs_error_t SrsRtmpConn::do_publishing(SrsSharedPtr<SrsLiveSource> source, SrsPu
}
#ifdef SRS_APM
ISrsApmSpan* span = _srs_apm->span("publish-cycle")->set_kind(SrsApmKindProducer)->as_child(span_client_)
->attr("timeout", srs_fmt("%d", srsu2msi(publish_normal_timeout)))->end();
SrsAutoFree(ISrsApmSpan, span);
SrsUniquePtr<ISrsApmSpan> span(_srs_apm->span("publish-cycle")->set_kind(SrsApmKindProducer)->as_child(span_client_)
->attr("timeout", srs_fmt("%d", srsu2msi(publish_normal_timeout)))->end());
#endif
// Response the start publishing message, let client start to publish messages.
@ -1062,7 +1059,7 @@ srs_error_t SrsRtmpConn::do_publishing(SrsSharedPtr<SrsLiveSource> source, SrsPu
#ifdef SRS_APM
// TODO: Do not use pithy print for frame span.
ISrsApmSpan* sample = _srs_apm->span("publish-frame")->set_kind(SrsApmKindConsumer)->as_child(span)
ISrsApmSpan* sample = _srs_apm->span("publish-frame")->set_kind(SrsApmKindConsumer)->as_child(span.get())
->attr("msgs", srs_fmt("%" PRId64, nb_frames))->attr("kbps", srs_fmt("%d", kbps->get_recv_kbps_30s()));
srs_freep(sample);
#endif
@ -1158,12 +1155,12 @@ 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 = NULL;
if ((err = rtmp->decode_message(msg, &pkt)) != srs_success) {
SrsPacket* pkt_raw = NULL;
if ((err = rtmp->decode_message(msg, &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "rtmp: decode message");
}
SrsAutoFree(SrsPacket, pkt);
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
// for flash, any packet is republish.
if (info->type == SrsRtmpConnFlashPublish) {
// flash unpublish.
@ -1173,8 +1170,8 @@ srs_error_t SrsRtmpConn::handle_publish_message(SrsSharedPtr<SrsLiveSource>& sou
}
// for fmle, drop others except the fmle start packet.
if (dynamic_cast<SrsFMLEStartPacket*>(pkt)) {
SrsFMLEStartPacket* unpublish = dynamic_cast<SrsFMLEStartPacket*>(pkt);
if (dynamic_cast<SrsFMLEStartPacket*>(pkt.get())) {
SrsFMLEStartPacket* unpublish = dynamic_cast<SrsFMLEStartPacket*>(pkt.get());
if ((err = rtmp->fmle_unpublish(info->res->stream_id, unpublish->transaction_id)) != srs_success) {
return srs_error_wrap(err, "rtmp: republish");
}
@ -1230,14 +1227,14 @@ 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 = NULL;
if ((err = rtmp->decode_message(msg, &pkt)) != srs_success) {
SrsPacket* pkt_raw = NULL;
if ((err = rtmp->decode_message(msg, &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "rtmp: decode message");
}
SrsAutoFree(SrsPacket, pkt);
if (dynamic_cast<SrsOnMetaDataPacket*>(pkt)) {
SrsOnMetaDataPacket* metadata = dynamic_cast<SrsOnMetaDataPacket*>(pkt);
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
if (dynamic_cast<SrsOnMetaDataPacket*>(pkt.get())) {
SrsOnMetaDataPacket* metadata = dynamic_cast<SrsOnMetaDataPacket*>(pkt.get());
if ((err = source->on_meta_data(msg, metadata)) != srs_success) {
return srs_error_wrap(err, "rtmp: consume metadata");
}
@ -1249,27 +1246,27 @@ srs_error_t SrsRtmpConn::process_publish_message(SrsSharedPtr<SrsLiveSource>& so
return err;
}
srs_error_t SrsRtmpConn::process_play_control_msg(SrsLiveConsumer* consumer, SrsCommonMessage* msg)
srs_error_t SrsRtmpConn::process_play_control_msg(SrsLiveConsumer* consumer, SrsCommonMessage* msg_raw)
{
srs_error_t err = srs_success;
if (!msg) {
if (!msg_raw) {
return err;
}
SrsAutoFree(SrsCommonMessage, msg);
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
if (!msg->header.is_amf0_command() && !msg->header.is_amf3_command()) {
return err;
}
SrsPacket* pkt = NULL;
if ((err = rtmp->decode_message(msg, &pkt)) != srs_success) {
SrsPacket* pkt_raw = NULL;
if ((err = rtmp->decode_message(msg.get(), &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "rtmp: decode message");
}
SrsAutoFree(SrsPacket, pkt);
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
// for jwplayer/flowplayer, which send close as pause message.
SrsCloseStreamPacket* close = dynamic_cast<SrsCloseStreamPacket*>(pkt);
SrsCloseStreamPacket* close = dynamic_cast<SrsCloseStreamPacket*>(pkt.get());
if (close) {
return srs_error_new(ERROR_CONTROL_RTMP_CLOSE, "rtmp: close stream");
}
@ -1277,7 +1274,7 @@ srs_error_t SrsRtmpConn::process_play_control_msg(SrsLiveConsumer* consumer, Srs
// call msg,
// support response null first,
// TODO: FIXME: response in right way, or forward in edge mode.
SrsCallPacket* call = dynamic_cast<SrsCallPacket*>(pkt);
SrsCallPacket* call = dynamic_cast<SrsCallPacket*>(pkt.get());
if (call) {
// only response it when transaction id not zero,
// for the zero means donot need response.
@ -1293,7 +1290,7 @@ srs_error_t SrsRtmpConn::process_play_control_msg(SrsLiveConsumer* consumer, Srs
}
// pause
SrsPausePacket* pause = dynamic_cast<SrsPausePacket*>(pkt);
SrsPausePacket* pause = dynamic_cast<SrsPausePacket*>(pkt.get());
if (pause) {
if ((err = rtmp->on_play_client_pause(info->res->stream_id, pause->is_pause)) != srs_success) {
return srs_error_wrap(err, "rtmp: pause");
@ -1343,19 +1340,16 @@ srs_error_t SrsRtmpConn::check_edge_token_traverse_auth()
string server;
int port = SRS_CONSTS_RTMP_DEFAULT_PORT;
srs_parse_hostport(hostport, server, port);
SrsTcpClient* transport = new SrsTcpClient(server, port, SRS_EDGE_TOKEN_TRAVERSE_TIMEOUT);
SrsAutoFree(SrsTcpClient, transport);
SrsUniquePtr<SrsTcpClient> transport(new SrsTcpClient(server, port, SRS_EDGE_TOKEN_TRAVERSE_TIMEOUT));
if ((err = transport->connect()) != srs_success) {
srs_warn("Illegal edge token, tcUrl=%s, %s", req->tcUrl.c_str(), srs_error_desc(err).c_str());
srs_freep(err);
continue;
}
SrsRtmpClient* client = new SrsRtmpClient(transport);
SrsAutoFree(SrsRtmpClient, client);
return do_token_traverse_auth(client);
SrsUniquePtr<SrsRtmpClient> client(new SrsRtmpClient(transport.get()));
return do_token_traverse_auth(client.get());
}
return srs_error_new(ERROR_EDGE_PORT_INVALID, "rtmp: Illegal edge token, server=%d", (int)args.size());
@ -1611,8 +1605,7 @@ srs_error_t SrsRtmpConn::cycle()
#ifdef SRS_APM
// Final APM span, parent is the last span, not the root span. Note that only client or server kind will be filtered
// for error or exception report.
ISrsApmSpan* span_final = _srs_apm->span("final")->set_kind(SrsApmKindServer)->as_child(span_client_);
SrsAutoFree(ISrsApmSpan, span_final);
SrsUniquePtr<ISrsApmSpan> span_final(_srs_apm->span("final")->set_kind(SrsApmKindServer)->as_child(span_client_));
if (srs_error_code(err) != 0) {
span_final->record_error(err)->set_status(SrsApmStatusError, srs_fmt("fail code=%d", srs_error_code(err)));
}

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

@ -1530,8 +1530,7 @@ srs_error_t SrsOriginHub::create_backend_forwarders(bool& applied)
std::string url = *it;
// create temp Request by url
SrsRequest* req = new SrsRequest();
SrsAutoFree(SrsRequest, req);
SrsUniquePtr<SrsRequest> req(new SrsRequest());
srs_parse_rtmp_url(url, req->tcUrl, req->stream);
srs_discovery_tc_url(req->tcUrl, req->schema, req->host, req->vhost, req->app, req->stream, req->port, req->param);
@ -1543,7 +1542,7 @@ srs_error_t SrsOriginHub::create_backend_forwarders(bool& applied)
forward_server << req->host << ":" << req->port;
// initialize the forwarder with request.
if ((err = forwarder->initialize(req, forward_server.str())) != srs_success) {
if ((err = forwarder->initialize(req.get(), forward_server.str())) != srs_success) {
return srs_error_wrap(err, "init backend forwarder failed, forward-to=%s", forward_server.str().c_str());
}
@ -2474,10 +2473,9 @@ srs_error_t SrsLiveSource::on_video_imp(SrsSharedPtrMessage* msg)
srs_error_t SrsLiveSource::on_aggregate(SrsCommonMessage* msg)
{
srs_error_t err = srs_success;
SrsBuffer* stream = new SrsBuffer(msg->payload, msg->size);
SrsAutoFree(SrsBuffer, stream);
SrsUniquePtr<SrsBuffer> stream(new SrsBuffer(msg->payload, msg->size));
// the aggregate message always use abs time.
int delta = -1;
@ -2662,13 +2660,6 @@ void SrsLiveSource::on_unpublish()
srs_error_t SrsLiveSource::create_consumer(SrsLiveConsumer*& consumer)
{
srs_error_t err = srs_success;
consumer = new SrsLiveConsumer(this);
consumers.push_back(consumer);
// There should be one consumer, so reset the timeout.
stream_die_at_ = 0;
publisher_idle_at_ = 0;
// for edge, when play edge stream, check the state
if (_srs_config->get_vhost_is_edge(req->vhost)) {
@ -2677,6 +2668,13 @@ srs_error_t SrsLiveSource::create_consumer(SrsLiveConsumer*& consumer)
return srs_error_wrap(err, "play edge");
}
}
consumer = new SrsLiveConsumer(this);
consumers.push_back(consumer);
// There are more than one consumer, so reset the timeout.
stream_die_at_ = 0;
publisher_idle_at_ = 0;
return err;
}

31
trunk/src/app/srs_app_srt_conn.cpp
View file

@ -439,8 +439,7 @@ srs_error_t SrsMpegtsSrtConn::do_publishing()
{
srs_error_t err = srs_success;
SrsPithyPrint* pprint = SrsPithyPrint::create_srt_publish();
SrsAutoFree(SrsPithyPrint, pprint);
SrsUniquePtr<SrsPithyPrint> pprint(SrsPithyPrint::create_srt_publish());
int nb_packets = 0;
@ -487,20 +486,20 @@ srs_error_t SrsMpegtsSrtConn::do_playing()
{
srs_error_t err = srs_success;
SrsSrtConsumer* consumer = NULL;
SrsAutoFree(SrsSrtConsumer, consumer);
if ((err = srt_source_->create_consumer(consumer)) != srs_success) {
SrsSrtConsumer* consumer_raw = NULL;
if ((err = srt_source_->create_consumer(consumer_raw)) != srs_success) {
return srs_error_wrap(err, "create consumer, ts source=%s", req_->get_stream_url().c_str());
}
srs_assert(consumer);
srs_assert(consumer_raw);
SrsUniquePtr<SrsSrtConsumer> consumer(consumer_raw);
// TODO: FIXME: Dumps the SPS/PPS from gop cache, without other frames.
if ((err = srt_source_->consumer_dumps(consumer)) != srs_success) {
if ((err = srt_source_->consumer_dumps(consumer.get())) != srs_success) {
return srs_error_wrap(err, "dumps consumer, url=%s", req_->get_stream_url().c_str());
}
SrsPithyPrint* pprint = SrsPithyPrint::create_srt_play();
SrsAutoFree(SrsPithyPrint, pprint);
SrsUniquePtr<SrsPithyPrint> pprint(SrsPithyPrint::create_srt_play());
SrsSrtRecvThread srt_recv_trd(srt_conn_);
if ((err = srt_recv_trd.start()) != srs_success) {
@ -519,15 +518,16 @@ srs_error_t SrsMpegtsSrtConn::do_playing()
}
// Wait for amount of packets.
SrsSrtPacket* pkt = NULL;
SrsAutoFree(SrsSrtPacket, pkt);
consumer->dump_packet(&pkt);
if (!pkt) {
SrsSrtPacket* pkt_raw = NULL;
consumer->dump_packet(&pkt_raw);
if (!pkt_raw) {
// TODO: FIXME: We should check the quit event.
consumer->wait(1, 1000 * SRS_UTIME_MILLISECONDS);
continue;
}
SrsUniquePtr<SrsSrtPacket> pkt(pkt_raw);
++nb_packets;
// reportable
@ -580,11 +580,10 @@ srs_error_t SrsMpegtsSrtConn::on_srt_packet(char* buf, int nb_buf)
return srs_error_new(ERROR_SRT_CONN, "invalid ts packet first=%#x", (uint8_t)buf[0]);
}
SrsSrtPacket* packet = new SrsSrtPacket();
SrsAutoFree(SrsSrtPacket, packet);
SrsUniquePtr<SrsSrtPacket> packet(new SrsSrtPacket());
packet->wrap(buf, nb_buf);
if ((err = srt_source_->on_packet(packet)) != srs_success) {
if ((err = srt_source_->on_packet(packet.get())) != srs_success) {
return srs_error_wrap(err, "on srt packet");
}

26
trunk/src/app/srs_app_srt_source.cpp
View file

@ -307,13 +307,11 @@ srs_error_t SrsSrtFrameBuilder::on_packet(SrsSrtPacket *pkt)
int nb_packet = nb_buf / SRS_TS_PACKET_SIZE;
for (int i = 0; i < nb_packet; i++) {
char* p = buf + (i * SRS_TS_PACKET_SIZE);
SrsBuffer* stream = new SrsBuffer(p, SRS_TS_PACKET_SIZE);
SrsAutoFree(SrsBuffer, stream);
SrsUniquePtr<SrsBuffer> stream(new SrsBuffer(p, SRS_TS_PACKET_SIZE));
// Process each ts packet. Note that the jitter of UDP may cause video glitch when packet loss or wrong seq. We
// don't handle it because SRT will, see tlpktdrop at https://ossrs.net/lts/zh-cn/docs/v4/doc/srt-params
if ((err = ts_ctx_->decode(stream, this)) != srs_success) {
if ((err = ts_ctx_->decode(stream.get(), this)) != srs_success) {
srs_warn("parse ts packet err=%s", srs_error_desc(err).c_str());
srs_error_reset(err);
continue;
@ -391,9 +389,8 @@ srs_error_t SrsSrtFrameBuilder::on_ts_video_avc(SrsTsMessage* msg, SrsBuffer* av
vector<pair<char*, int> > ipb_frames;
SrsRawH264Stream* avc = new SrsRawH264Stream();
SrsAutoFree(SrsRawH264Stream, avc);
SrsUniquePtr<SrsRawH264Stream> avc(new SrsRawH264Stream());
// send each frame.
while (!avs->empty()) {
char* frame = NULL;
@ -465,8 +462,7 @@ srs_error_t SrsSrtFrameBuilder::check_sps_pps_change(SrsTsMessage* msg)
uint32_t dts = (uint32_t)(msg->dts / 90);
std::string sh;
SrsRawH264Stream* avc = new SrsRawH264Stream();
SrsAutoFree(SrsRawH264Stream, avc);
SrsUniquePtr<SrsRawH264Stream> avc(new SrsRawH264Stream());
if ((err = avc->mux_sequence_header(sps_, pps_, sh)) != srs_success) {
return srs_error_wrap(err, "mux sequence header");
@ -565,9 +561,7 @@ srs_error_t SrsSrtFrameBuilder::on_ts_video_hevc(SrsTsMessage *msg, SrsBuffer *a
srs_error_t err = srs_success;
vector<pair<char*, int> > ipb_frames;
SrsRawHEVCStream *hevc = new SrsRawHEVCStream();
SrsAutoFree(SrsRawHEVCStream, hevc);
SrsUniquePtr<SrsRawHEVCStream> hevc(new SrsRawHEVCStream());
std::vector<std::string> hevc_pps;
// send each frame.
@ -660,8 +654,7 @@ srs_error_t SrsSrtFrameBuilder::check_vps_sps_pps_change(SrsTsMessage* msg)
uint32_t dts = (uint32_t)(msg->dts / 90);
std::string sh;
SrsRawHEVCStream* hevc = new SrsRawHEVCStream();
SrsAutoFree(SrsRawHEVCStream, hevc);
SrsUniquePtr<SrsRawHEVCStream> hevc(new SrsRawHEVCStream());
if ((err = hevc->mux_sequence_header(hevc_vps_, hevc_sps_, hevc_pps_, sh)) != srs_success) {
return srs_error_wrap(err, "mux sequence header");
@ -765,9 +758,8 @@ srs_error_t SrsSrtFrameBuilder::on_hevc_frame(SrsTsMessage* msg, vector<pair<cha
srs_error_t SrsSrtFrameBuilder::on_ts_audio(SrsTsMessage* msg, SrsBuffer* avs)
{
srs_error_t err = srs_success;
SrsRawAacStream* aac = new SrsRawAacStream();
SrsAutoFree(SrsRawAacStream, aac);
SrsUniquePtr<SrsRawAacStream> aac(new SrsRawAacStream());
// ts tbn to flv tbn.
uint32_t pts = (uint32_t)(msg->pts / 90);

43
trunk/src/app/srs_app_tencentcloud.cpp
View file

@ -706,11 +706,10 @@ srs_error_t SrsClsClient::report()
return err;
}
SrsClsSugars* sugars = sugars_;
SrsAutoFree(SrsClsSugars, sugars);
SrsUniquePtr<SrsClsSugars> sugars(sugars_);
sugars_ = new SrsClsSugars();
if ((err = send_logs(sugars)) != srs_success) {
if ((err = send_logs(sugars.get())) != srs_success) {
return srs_error_wrap(err, "cls");
}
@ -727,16 +726,15 @@ srs_error_t SrsClsClient::do_send_logs(ISrsEncoder* sugar, int count, int total)
return srs_error_new(ERROR_CLS_EXCEED_SIZE, "exceed 5MB actual %d", size);
}
char* buf = new char[size];
SrsAutoFreeA(char, buf);
SrsUniquePtr<char[]> buf(new char[size]);
memset(buf, 0, size);
SrsBuffer b(buf, size);
memset(buf.get(), 0, size);
SrsBuffer b(buf.get(), size);
if ((err = sugar->encode(&b)) != srs_success) {
return srs_error_wrap(err, "encode log");
}
string body(buf, size);
string body(buf.get(), size);
// Write a CLS log to service specified by url.
string url = "http://" + endpoint_ + ":80/structuredlog?topic_id=" + topic_;
@ -776,11 +774,11 @@ srs_error_t SrsClsClient::do_send_logs(ISrsEncoder* sugar, int count, int total)
}
// Start request and parse response.
ISrsHttpMessage* msg = NULL;
if ((err = http.post(path, body, &msg)) != srs_success) {
ISrsHttpMessage* msg_raw = NULL;
if ((err = http.post(path, body, &msg_raw)) != srs_success) {
return srs_error_wrap(err, "http: client post");
}
SrsAutoFree(ISrsHttpMessage, msg);
SrsUniquePtr<ISrsHttpMessage> msg(msg_raw);
string res;
uint16_t code = msg->status_code();
@ -819,10 +817,9 @@ srs_error_t SrsClsClient::send_logs(SrsClsSugars* sugars)
// Never do infinite loop, limit to a max loop and drop logs if exceed.
for (int i = 0; i < 128 && !sugars->empty(); ++i) {
SrsClsSugars* v = sugars->slice(SRS_CLS_BATCH_MAX_LOG_SIZE);
SrsAutoFree(SrsClsSugars, v);
SrsUniquePtr<SrsClsSugars> v(sugars->slice(SRS_CLS_BATCH_MAX_LOG_SIZE));
if ((err = do_send_logs((ISrsEncoder*)v, v->size(), total)) != srs_success) {
if ((err = do_send_logs((ISrsEncoder*)v.get(), v->size(), total)) != srs_success) {
return srs_error_wrap(err, "send %d/%d/%d logs", v->size(), i, total);
}
}
@ -2148,8 +2145,7 @@ srs_error_t SrsApmClient::do_report()
// Update statistaic for APM.
nn_spans_ += spans_.size();
SrsOtelExportTraceServiceRequest* sugar = new SrsOtelExportTraceServiceRequest();
SrsAutoFree(SrsOtelExportTraceServiceRequest, sugar);
SrsUniquePtr<SrsOtelExportTraceServiceRequest> sugar(new SrsOtelExportTraceServiceRequest());
SrsOtelResourceSpans* rs = sugar->append();
// See https://github.com/open-telemetry/opentelemetry-specification/tree/main/specification/resource/semantic_conventions
@ -2169,16 +2165,15 @@ srs_error_t SrsApmClient::do_report()
return srs_error_new(ERROR_APM_EXCEED_SIZE, "exceed 5MB actual %d", size);
}
char* buf = new char[size];
SrsAutoFreeA(char, buf);
SrsUniquePtr<char[]> buf(new char[size]);
memset(buf, 0, size);
SrsBuffer b(buf, size);
memset(buf.get(), 0, size);
SrsBuffer b(buf.get(), size);
if ((err = sugar->encode(&b)) != srs_success) {
return srs_error_wrap(err, "encode log");
}
string body(buf, size);
string body(buf.get(), size);
// Write a CLS log to service specified by url.
string url = "http://" + endpoint_ + "/v1/traces";
@ -2204,11 +2199,11 @@ srs_error_t SrsApmClient::do_report()
}
// Start request and parse response.
ISrsHttpMessage* msg = NULL;
if ((err = http.post(path, body, &msg)) != srs_success) {
ISrsHttpMessage* msg_raw = NULL;
if ((err = http.post(path, body, &msg_raw)) != srs_success) {
return srs_error_wrap(err, "http: client post");
}
SrsAutoFree(ISrsHttpMessage, msg);
SrsUniquePtr<ISrsHttpMessage> msg(msg_raw);
string res;
uint16_t code = msg->status_code();