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

For #913, APP support complex error.

Browse source
This commit is contained in:
winlin 2018-01-01 22:32:54 +08:00
parent e2c1f58674
commit db08f1586c
14 changed files with 623 additions and 591 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -49,25 +49,24 @@ SrsInitMp4::~SrsInitMp4()
srs_freep(fw);
}
int SrsInitMp4::write(SrsFormat* format, bool video, int tid)
srs_error_t SrsInitMp4::write(SrsFormat* format, bool video, int tid)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
string path_tmp = tmppath();
if ((ret = fw->open(path_tmp)) != ERROR_SUCCESS) {
srs_error("DASH: Open init mp4 failed, path=%s, ret=%d", path_tmp.c_str(), ret);
return ret;
if ((err = fw->open(path_tmp)) != srs_success) {
return srs_error_wrap(err, "Open init mp4 failed, path=%s", path_tmp.c_str());
}
if ((ret = init->initialize(fw)) != ERROR_SUCCESS) {
return ret;
if ((err = init->initialize(fw)) != srs_success) {
return srs_error_wrap(err, "init");
}
if ((ret = init->write(format, video, tid)) != ERROR_SUCCESS) {
return ret;
if ((err = init->write(format, video, tid)) != srs_success) {
return srs_error_wrap(err, "write init");
}
return ret;
return err;
}
SrsFragmentedMp4::SrsFragmentedMp4()
@ -82,52 +81,47 @@ SrsFragmentedMp4::~SrsFragmentedMp4()
srs_freep(fw);
}
int SrsFragmentedMp4::initialize(SrsRequest* r, bool video, SrsMpdWriter* mpd, uint32_t tid)
srs_error_t SrsFragmentedMp4::initialize(SrsRequest* r, bool video, SrsMpdWriter* mpd, uint32_t tid)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
string file_home;
string file_name;
int64_t sequence_number;
uint64_t basetime;
if ((ret = mpd->get_fragment(video, file_home, file_name, sequence_number, basetime)) != ERROR_SUCCESS) {
return ret;
if ((err = mpd->get_fragment(video, file_home, file_name, sequence_number, basetime)) != srs_success) {
return srs_error_wrap(err, "get fragment");
}
string home = _srs_config->get_dash_path(r->vhost);
set_path(home + "/" + file_home + "/" + file_name);
if ((err = create_dir()) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret;
return srs_error_wrap(err, "create dir");
}
string path_tmp = tmppath();
if ((ret = fw->open(path_tmp)) != ERROR_SUCCESS) {
srs_error("DASH: Open fmp4 failed, path=%s, ret=%d", path_tmp.c_str(), ret);
return ret;
if ((err = fw->open(path_tmp)) != srs_success) {
return srs_error_wrap(err, "Open fmp4 failed, path=%s", path_tmp.c_str());
}
if ((ret = enc->initialize(fw, (uint32_t)sequence_number, basetime, tid)) != ERROR_SUCCESS) {
return ret;
if ((err = enc->initialize(fw, (uint32_t)sequence_number, basetime, tid)) != srs_success) {
return srs_error_wrap(err, "init encoder");
}
return ret;
return err;
}
int SrsFragmentedMp4::write(SrsSharedPtrMessage* shared_msg, SrsFormat* format)
srs_error_t SrsFragmentedMp4::write(SrsSharedPtrMessage* shared_msg, SrsFormat* format)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (shared_msg->is_audio()) {
uint8_t* sample = (uint8_t*)format->raw;
uint32_t nb_sample = (uint32_t)format->nb_raw;
uint32_t dts = (uint32_t)shared_msg->timestamp;
ret = enc->write_sample(SrsMp4HandlerTypeSOUN, 0x00, dts, dts, sample, nb_sample);
err = enc->write_sample(SrsMp4HandlerTypeSOUN, 0x00, dts, dts, sample, nb_sample);
} else if (shared_msg->is_video()) {
SrsVideoAvcFrameType frame_type = format->video->frame_type;
uint32_t cts = (uint32_t)format->video->cts;
@ -137,36 +131,31 @@ int SrsFragmentedMp4::write(SrsSharedPtrMessage* shared_msg, SrsFormat* format)
uint8_t* sample = (uint8_t*)format->raw;
uint32_t nb_sample = (uint32_t)format->nb_raw;
ret = enc->write_sample(SrsMp4HandlerTypeVIDE, frame_type, dts, pts, sample, nb_sample);
err = enc->write_sample(SrsMp4HandlerTypeVIDE, frame_type, dts, pts, sample, nb_sample);
} else {
return ret;
return err;
}
append(shared_msg->timestamp);
return ret;
return err;
}
int SrsFragmentedMp4::reap(uint64_t& dts)
srs_error_t SrsFragmentedMp4::reap(uint64_t& dts)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if ((ret = enc->flush(dts)) != ERROR_SUCCESS) {
srs_error("DASH: Flush encoder failed, ret=%d", ret);
return ret;
if ((err = enc->flush(dts)) != srs_success) {
return srs_error_wrap(err, "Flush encoder failed");
}
srs_freep(fw);
if ((err = rename()) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret;
return srs_error_wrap(err, "rename");
}
return ret;
return err;
}
SrsMpdWriter::SrsMpdWriter()
@ -196,14 +185,13 @@ srs_error_t SrsMpdWriter::initialize(SrsRequest* r)
return srs_success;
}
int SrsMpdWriter::write(SrsFormat* format)
srs_error_t SrsMpdWriter::write(SrsFormat* format)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// MPD is not expired?
if (last_update_mpd != -1 && srs_get_system_time_ms() - last_update_mpd < update_period) {
return ret;
return err;
}
last_update_mpd = srs_get_system_time_ms();
@ -214,11 +202,7 @@ int SrsMpdWriter::write(SrsFormat* format)
fragment_home = srs_path_dirname(mpd_path) + "/" + req->stream;
if ((err = srs_create_dir_recursively(full_home)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
srs_error("DASH: Create MPD home failed, home=%s, ret=%d", full_home.c_str(), ret);
return ret;
return srs_error_wrap(err, "Create MPD home failed, home=%s", full_home.c_str());
}
stringstream ss;
@ -257,31 +241,27 @@ int SrsMpdWriter::write(SrsFormat* format)
SrsAutoFree(SrsFileWriter, fw);
string full_path_tmp = full_path + ".tmp";
if ((ret = fw->open(full_path_tmp)) != ERROR_SUCCESS) {
srs_error("DASH: Open MPD file=%s failed, ret=%d", full_path_tmp.c_str(), ret);
return ret;
if ((err = fw->open(full_path_tmp)) != srs_success) {
return srs_error_wrap(err, "Open MPD file=%s failed", full_path_tmp.c_str());
}
string content = ss.str();
if ((ret = fw->write((void*)content.data(), content.length(), NULL)) != ERROR_SUCCESS) {
srs_error("DASH: Write MPD file=%s failed, ret=%d", full_path.c_str(), ret);
return ret;
if ((err = fw->write((void*)content.data(), content.length(), NULL)) != srs_success) {
return srs_error_wrap(err, "Write MPD file=%s failed", full_path.c_str());
}
if (::rename(full_path_tmp.c_str(), full_path.c_str()) < 0) {
ret = ERROR_DASH_WRITE_FAILED;
srs_error("DASH: Rename %s to %s failed, ret=%d", full_path_tmp.c_str(), full_path.c_str(), ret);
return ret;
return srs_error_new(ERROR_DASH_WRITE_FAILED, "Rename %s to %s failed", full_path_tmp.c_str(), full_path.c_str());
}
srs_trace("DASH: Refresh MPD success, size=%dB, file=%s", content.length(), full_path.c_str());
return ret;
return err;
}
int SrsMpdWriter::get_fragment(bool video, std::string& home, std::string& file_name, int64_t& sn, uint64_t& basetime)
srs_error_t SrsMpdWriter::get_fragment(bool video, std::string& home, std::string& file_name, int64_t& sn, uint64_t& basetime)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
home = fragment_home;
@ -294,7 +274,7 @@ int SrsMpdWriter::get_fragment(bool video, std::string& home, std::string& file_
file_name = "audio-" + srs_int2str(sn) + ".m4s";
}
return ret;
return err;
}
SrsDashController::SrsDashController()
@ -320,7 +300,6 @@ SrsDashController::~SrsDashController()
srs_error_t SrsDashController::initialize(SrsRequest* r)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
req = r;
@ -335,125 +314,113 @@ srs_error_t SrsDashController::initialize(SrsRequest* r)
srs_freep(vcurrent);
vcurrent = new SrsFragmentedMp4();
if ((ret = vcurrent->initialize(req, true, mpd, video_tack_id)) != ERROR_SUCCESS) {
return srs_error_new(ret, "video fragment");
if ((err = vcurrent->initialize(req, true, mpd, video_tack_id)) != srs_success) {
return srs_error_wrap(err, "video fragment");
}
srs_freep(acurrent);
acurrent = new SrsFragmentedMp4();
if ((ret = acurrent->initialize(req, false, mpd, audio_track_id)) != ERROR_SUCCESS) {
return srs_error_new(ret, "audio fragment");
if ((err = acurrent->initialize(req, false, mpd, audio_track_id)) != srs_success) {
return srs_error_wrap(err, "audio fragment");
}
return err;
}
int SrsDashController::on_audio(SrsSharedPtrMessage* shared_audio, SrsFormat* format)
srs_error_t SrsDashController::on_audio(SrsSharedPtrMessage* shared_audio, SrsFormat* format)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (format->is_aac_sequence_header()) {
return refresh_init_mp4(shared_audio, format);
}
if (acurrent->duration() >= fragment) {
if ((ret = acurrent->reap(audio_dts)) != ERROR_SUCCESS) {
return ret;
if ((err = acurrent->reap(audio_dts)) != srs_success) {
return srs_error_wrap(err, "reap current");
}
afragments->append(acurrent);
acurrent = new SrsFragmentedMp4();
if ((ret = acurrent->initialize(req, false, mpd, audio_track_id)) != ERROR_SUCCESS) {
srs_error("DASH: Initialize the audio fragment failed, ret=%d", ret);
return ret;
if ((err = acurrent->initialize(req, false, mpd, audio_track_id)) != srs_success) {
return srs_error_wrap(err, "Initialize the audio fragment failed");
}
}
if ((ret = acurrent->write(shared_audio, format)) != ERROR_SUCCESS) {
srs_error("DASH: Write audio to fragment failed, ret=%d", ret);
return ret;
if ((err = acurrent->write(shared_audio, format)) != srs_success) {
return srs_error_wrap(err, "Write audio to fragment failed");
}
if ((ret = refresh_mpd(format)) != ERROR_SUCCESS) {
srs_error("DASH: Refresh the MPD failed. ret=%d", ret);
return ret;
if ((err = refresh_mpd(format)) != srs_success) {
return srs_error_wrap(err, "Refresh the MPD failed");
}
return ret;
return err;
}
int SrsDashController::on_video(SrsSharedPtrMessage* shared_video, SrsFormat* format)
srs_error_t SrsDashController::on_video(SrsSharedPtrMessage* shared_video, SrsFormat* format)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (format->is_avc_sequence_header()) {
return refresh_init_mp4(shared_video, format);
}
bool reopen = format->video->frame_type == SrsVideoAvcFrameTypeKeyFrame
&& vcurrent->duration() >= fragment;
bool reopen = format->video->frame_type == SrsVideoAvcFrameTypeKeyFrame && vcurrent->duration() >= fragment;
if (reopen) {
if ((ret = vcurrent->reap(video_dts)) != ERROR_SUCCESS) {
return ret;
if ((err = vcurrent->reap(video_dts)) != srs_success) {
return srs_error_wrap(err, "reap current");
}
vfragments->append(vcurrent);
vcurrent = new SrsFragmentedMp4();
if ((ret = vcurrent->initialize(req, true, mpd, video_tack_id)) != ERROR_SUCCESS) {
srs_error("DASH: Initialize the video fragment failed, ret=%d", ret);
return ret;
if ((err = vcurrent->initialize(req, true, mpd, video_tack_id)) != srs_success) {
return srs_error_wrap(err, "Initialize the video fragment failed");
}
}
if ((ret = vcurrent->write(shared_video, format)) != ERROR_SUCCESS) {
srs_error("DASH: Write video to fragment failed, ret=%d", ret);
return ret;
if ((err = vcurrent->write(shared_video, format)) != srs_success) {
return srs_error_wrap(err, "Write video to fragment failed");
}
if ((ret = refresh_mpd(format)) != ERROR_SUCCESS) {
srs_error("DASH: Refresh the MPD failed. ret=%d", ret);
return ret;
if ((err = refresh_mpd(format)) != srs_success) {
return srs_error_wrap(err, "Refresh the MPD failed");
}
return ret;
return err;
}
int SrsDashController::refresh_mpd(SrsFormat* format)
srs_error_t SrsDashController::refresh_mpd(SrsFormat* format)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// TODO: FIXME: Support pure audio streaming.
if (!format->acodec || !format->vcodec) {
return ret;
return err;
}
if ((ret = mpd->write(format)) != ERROR_SUCCESS) {
return ret;
if ((err = mpd->write(format)) != srs_success) {
return srs_error_wrap(err, "write mpd");
}
return ret;
return err;
}
int SrsDashController::refresh_init_mp4(SrsSharedPtrMessage* msg, SrsFormat* format)
srs_error_t SrsDashController::refresh_init_mp4(SrsSharedPtrMessage* msg, SrsFormat* format)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (msg->size <= 0 || (msg->is_video() && !format->vcodec->is_avc_codec_ok())
|| (msg->is_audio() && !format->acodec->is_aac_codec_ok())) {
srs_warn("DASH: Ignore empty sequence header.");
return ret;
return err;
}
string full_home = home + "/" + req->app + "/" + req->stream;
if ((err = srs_create_dir_recursively(full_home)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
srs_error("DASH: Create media home failed, home=%s, ret=%d", full_home.c_str(), ret);
return ret;
return srs_error_wrap(err, "Create media home failed, home=%s", full_home.c_str());
}
std::string path = full_home;
@ -469,20 +436,17 @@ int SrsDashController::refresh_init_mp4(SrsSharedPtrMessage* msg, SrsFormat* for
init_mp4->set_path(path);
int tid = msg->is_video()? video_tack_id:audio_track_id;
if ((ret = init_mp4->write(format, msg->is_video(), tid)) != ERROR_SUCCESS) {
return ret;
if ((err = init_mp4->write(format, msg->is_video(), tid)) != srs_success) {
return srs_error_wrap(err, "write init");
}
if ((err = init_mp4->rename()) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret;
return srs_error_wrap(err, "rename init");
}
srs_trace("DASH: Refresh media success, file=%s", path.c_str());
return ret;
return err;
}
SrsDash::SrsDash()
@ -513,53 +477,51 @@ srs_error_t SrsDash::initialize(SrsOriginHub* h, SrsRequest* r)
return err;
}
int SrsDash::on_publish()
srs_error_t SrsDash::on_publish()
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// Prevent duplicated publish.
if (enabled) {
return ret;
return err;
}
if (!_srs_config->get_dash_enabled(req->vhost)) {
return ret;
return err;
}
enabled = true;
return ret;
return err;
}
int SrsDash::on_audio(SrsSharedPtrMessage* shared_audio, SrsFormat* format)
srs_error_t SrsDash::on_audio(SrsSharedPtrMessage* shared_audio, SrsFormat* format)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (!enabled) {
return ret;
return err;
}
if ((ret = controller->on_audio(shared_audio, format)) != ERROR_SUCCESS) {
srs_error("DASH: Consume audio failed. ret=%d", ret);
return ret;
if ((err = controller->on_audio(shared_audio, format)) != srs_success) {
return srs_error_wrap(err, "Consume audio failed");
}
return ret;
return err;
}
int SrsDash::on_video(SrsSharedPtrMessage* shared_video, SrsFormat* format)
srs_error_t SrsDash::on_video(SrsSharedPtrMessage* shared_video, SrsFormat* format)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (!enabled) {
return ret;
return err;
}
if ((ret = controller->on_video(shared_video, format)) != ERROR_SUCCESS) {
srs_error("DASH: Consume video failed. ret=%d", ret);
return ret;
if ((err = controller->on_video(shared_video, format)) != srs_success) {
return srs_error_wrap(err, "Consume video failed");
}
return ret;
return err;
}
void SrsDash::on_unpublish()

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

@ -83,7 +83,6 @@ SrsFragment* SrsDvrSegmenter::current()
srs_error_t SrsDvrSegmenter::open()
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// ignore when already open.
@ -108,8 +107,8 @@ srs_error_t SrsDvrSegmenter::open()
// open file writer, in append or create mode.
string tmp_dvr_file = fragment->tmppath();
if ((ret = fs->open(tmp_dvr_file)) != ERROR_SUCCESS) {
return srs_error_new(ret, "open file %s", path.c_str());
if ((err = fs->open(tmp_dvr_file)) != srs_success) {
return srs_error_wrap(err, "open file %s", path.c_str());
}
// initialize the encoder.
@ -256,7 +255,6 @@ SrsDvrFlvSegmenter::~SrsDvrFlvSegmenter()
srs_error_t SrsDvrFlvSegmenter::refresh_metadata()
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// no duration or filesize specified.
@ -270,24 +268,21 @@ srs_error_t SrsDvrFlvSegmenter::refresh_metadata()
char* buf = new char[SrsAmf0Size::number()];
SrsAutoFreeA(char, buf);
SrsBuffer stream;
if ((ret = stream.initialize(buf, SrsAmf0Size::number())) != ERROR_SUCCESS) {
return srs_error_new(ret, "init stream");
}
SrsBuffer stream(buf, SrsAmf0Size::number());
// filesize to buf.
SrsAmf0Any* size = SrsAmf0Any::number((double)cur);
SrsAutoFree(SrsAmf0Any, size);
stream.skip(-1 * stream.pos());
if ((ret = size->write(&stream)) != ERROR_SUCCESS) {
return srs_error_new(ret, "write filesize");
if ((err = size->write(&stream)) != srs_success) {
return srs_error_wrap(err, "write filesize");
}
// update the flesize.
fs->seek2(filesize_offset);
if ((ret = fs->write(buf, SrsAmf0Size::number(), NULL)) != ERROR_SUCCESS) {
return srs_error_new(ret, "update filesize");
if ((err = fs->write(buf, SrsAmf0Size::number(), NULL)) != srs_success) {
return srs_error_wrap(err, "update filesize");
}
// duration to buf
@ -295,14 +290,14 @@ srs_error_t SrsDvrFlvSegmenter::refresh_metadata()
SrsAutoFree(SrsAmf0Any, dur);
stream.skip(-1 * stream.pos());
if ((ret = dur->write(&stream)) != ERROR_SUCCESS) {
return srs_error_new(ret, "write duration");
if ((err = dur->write(&stream)) != srs_success) {
return srs_error_wrap(err, "write duration");
}
// update the duration
fs->seek2(duration_offset);
if ((ret = fs->write(buf, SrsAmf0Size::number(), NULL)) != ERROR_SUCCESS) {
return srs_error_new(ret, "update duration");
if ((err = fs->write(buf, SrsAmf0Size::number(), NULL)) != srs_success) {
return srs_error_wrap(err, "update duration");
}
// reset the offset.
@ -313,7 +308,6 @@ srs_error_t SrsDvrFlvSegmenter::refresh_metadata()
srs_error_t SrsDvrFlvSegmenter::open_encoder()
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
has_keyframe = false;
@ -325,13 +319,13 @@ srs_error_t SrsDvrFlvSegmenter::open_encoder()
srs_freep(enc);
enc = new SrsFlvTransmuxer();
if ((ret = enc->initialize(fs)) != ERROR_SUCCESS) {
return srs_error_new(ret, "init encoder");
if ((err = enc->initialize(fs)) != srs_success) {
return srs_error_wrap(err, "init encoder");
}
// write the flv header to writer.
if ((ret = enc->write_header()) != ERROR_SUCCESS) {
return srs_error_new(ret, "write flv header");
if ((err = enc->write_header()) != srs_success) {
return srs_error_wrap(err, "write flv header");
}
return err;
@ -339,29 +333,25 @@ srs_error_t SrsDvrFlvSegmenter::open_encoder()
srs_error_t SrsDvrFlvSegmenter::encode_metadata(SrsSharedPtrMessage* metadata)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// Ignore when metadata already written.
if (duration_offset || filesize_offset) {
return err;
}
SrsBuffer stream;
if ((ret = stream.initialize(metadata->payload, metadata->size)) != ERROR_SUCCESS) {
return srs_error_new(ret, "init stream");
}
SrsBuffer stream(metadata->payload, metadata->size);
SrsAmf0Any* name = SrsAmf0Any::str();
SrsAutoFree(SrsAmf0Any, name);
if ((ret = name->read(&stream)) != ERROR_SUCCESS) {
return srs_error_new(ret, "read name");
if ((err = name->read(&stream)) != srs_success) {
return srs_error_wrap(err, "read name");
}
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
if ((ret = obj->read(&stream)) != ERROR_SUCCESS) {
return srs_error_new(ret, "read object");
if ((err = obj->read(&stream)) != srs_success) {
return srs_error_wrap(err, "read object");
}
// remove duration and filesize.
@ -383,19 +373,18 @@ srs_error_t SrsDvrFlvSegmenter::encode_metadata(SrsSharedPtrMessage* metadata)
filesize_offset = duration_offset - SrsAmf0Size::utf8("duration") - SrsAmf0Size::number();
// convert metadata to bytes.
if ((ret = stream.initialize(payload, size)) != ERROR_SUCCESS) {
return srs_error_new(ret, "init stream");
SrsBuffer buf(payload, size);
if ((err = name->write(&buf)) != srs_success) {
return srs_error_wrap(err, "write name");
}
if ((ret = name->write(&stream)) != ERROR_SUCCESS) {
return srs_error_new(ret, "write name");
}
if ((ret = obj->write(&stream)) != ERROR_SUCCESS) {
return srs_error_new(ret, "write object");
if ((err = obj->write(&buf)) != srs_success) {
return srs_error_wrap(err, "write object");
}
// to flv file.
if ((ret = enc->write_metadata(18, payload, size)) != ERROR_SUCCESS) {
return srs_error_new(ret, "write metadata");
if ((err = enc->write_metadata(18, payload, size)) != srs_success) {
return srs_error_wrap(err, "write metadata");
}
return err;
@ -403,13 +392,12 @@ srs_error_t SrsDvrFlvSegmenter::encode_metadata(SrsSharedPtrMessage* metadata)
srs_error_t SrsDvrFlvSegmenter::encode_audio(SrsSharedPtrMessage* audio, SrsFormat* format)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
char* payload = audio->payload;
int size = audio->size;
if ((ret = enc->write_audio(audio->timestamp, payload, size)) != ERROR_SUCCESS) {
return srs_error_new(ret, "write audio");
if ((err = enc->write_audio(audio->timestamp, payload, size)) != srs_success) {
return srs_error_wrap(err, "write audio");
}
return err;
@ -417,7 +405,6 @@ srs_error_t SrsDvrFlvSegmenter::encode_audio(SrsSharedPtrMessage* audio, SrsForm
srs_error_t SrsDvrFlvSegmenter::encode_video(SrsSharedPtrMessage* video, SrsFormat* format)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
char* payload = video->payload;
@ -435,8 +422,8 @@ srs_error_t SrsDvrFlvSegmenter::encode_video(SrsSharedPtrMessage* video, SrsForm
return err;
}
if ((ret = enc->write_video(video->timestamp, payload, size)) != ERROR_SUCCESS) {
return srs_error_new(ret, "write video");
if ((err = enc->write_video(video->timestamp, payload, size)) != srs_success) {
return srs_error_wrap(err, "write video");
}
return err;
@ -464,14 +451,13 @@ srs_error_t SrsDvrMp4Segmenter::refresh_metadata()
srs_error_t SrsDvrMp4Segmenter::open_encoder()
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
srs_freep(enc);
enc = new SrsMp4Encoder();
if ((ret = enc->initialize(fs)) != ERROR_SUCCESS) {
return srs_error_new(ret, "init encoder");
if ((err = enc->initialize(fs)) != srs_success) {
return srs_error_wrap(err, "init encoder");
}
return err;
@ -484,7 +470,6 @@ srs_error_t SrsDvrMp4Segmenter::encode_metadata(SrsSharedPtrMessage* /*metadata*
srs_error_t SrsDvrMp4Segmenter::encode_audio(SrsSharedPtrMessage* audio, SrsFormat* format)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
SrsAudioCodecId sound_format = format->acodec->id;
@ -504,8 +489,8 @@ srs_error_t SrsDvrMp4Segmenter::encode_audio(SrsSharedPtrMessage* audio, SrsForm
uint32_t nb_sample = (uint32_t)format->nb_raw;
uint32_t dts = (uint32_t)audio->timestamp;
if ((ret = enc->write_sample(SrsMp4HandlerTypeSOUN, 0x00, ct, dts, dts, sample, nb_sample)) != ERROR_SUCCESS) {
return srs_error_new(ret, "write sample");
if ((err = enc->write_sample(SrsMp4HandlerTypeSOUN, 0x00, ct, dts, dts, sample, nb_sample)) != srs_success) {
return srs_error_wrap(err, "write sample");
}
return err;
@ -513,7 +498,6 @@ srs_error_t SrsDvrMp4Segmenter::encode_audio(SrsSharedPtrMessage* audio, SrsForm
srs_error_t SrsDvrMp4Segmenter::encode_video(SrsSharedPtrMessage* video, SrsFormat* format)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
SrsVideoAvcFrameType frame_type = format->video->frame_type;
@ -531,8 +515,8 @@ srs_error_t SrsDvrMp4Segmenter::encode_video(SrsSharedPtrMessage* video, SrsForm
uint8_t* sample = (uint8_t*)format->raw;
uint32_t nb_sample = (uint32_t)format->nb_raw;
if ((ret = enc->write_sample(SrsMp4HandlerTypeVIDE, frame_type, ct, dts, pts, sample, nb_sample)) != ERROR_SUCCESS) {
return srs_error_new(ret, "write sample");
if ((err = enc->write_sample(SrsMp4HandlerTypeVIDE, frame_type, ct, dts, pts, sample, nb_sample)) != srs_success) {
return srs_error_wrap(err, "write sample");
}
return err;
@ -540,11 +524,10 @@ srs_error_t SrsDvrMp4Segmenter::encode_video(SrsSharedPtrMessage* video, SrsForm
srs_error_t SrsDvrMp4Segmenter::close_encoder()
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if ((ret = enc->flush()) != ERROR_SUCCESS) {
return srs_error_new(ret, "flush encoder");
if ((err = enc->flush()) != srs_success) {
return srs_error_wrap(err, "flush encoder");
}
return err;