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

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");
}