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); 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(); string path_tmp = tmppath();
if ((ret = fw->open(path_tmp)) != ERROR_SUCCESS) { if ((err = fw->open(path_tmp)) != srs_success) {
srs_error("DASH: Open init mp4 failed, path=%s, ret=%d", path_tmp.c_str(), ret); return srs_error_wrap(err, "Open init mp4 failed, path=%s", path_tmp.c_str());
return ret;
} }
if ((ret = init->initialize(fw)) != ERROR_SUCCESS) { if ((err = init->initialize(fw)) != srs_success) {
return ret; return srs_error_wrap(err, "init");
} }
if ((ret = init->write(format, video, tid)) != ERROR_SUCCESS) { if ((err = init->write(format, video, tid)) != srs_success) {
return ret; return srs_error_wrap(err, "write init");
} }
return ret; return err;
} }
SrsFragmentedMp4::SrsFragmentedMp4() SrsFragmentedMp4::SrsFragmentedMp4()
@ -82,52 +81,47 @@ SrsFragmentedMp4::~SrsFragmentedMp4()
srs_freep(fw); 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; srs_error_t err = srs_success;
string file_home; string file_home;
string file_name; string file_name;
int64_t sequence_number; int64_t sequence_number;
uint64_t basetime; uint64_t basetime;
if ((ret = mpd->get_fragment(video, file_home, file_name, sequence_number, basetime)) != ERROR_SUCCESS) { if ((err = mpd->get_fragment(video, file_home, file_name, sequence_number, basetime)) != srs_success) {
return ret; return srs_error_wrap(err, "get fragment");
} }
string home = _srs_config->get_dash_path(r->vhost); string home = _srs_config->get_dash_path(r->vhost);
set_path(home + "/" + file_home + "/" + file_name); set_path(home + "/" + file_home + "/" + file_name);
if ((err = create_dir()) != srs_success) { if ((err = create_dir()) != srs_success) {
// TODO: FIXME: Use error return srs_error_wrap(err, "create dir");
ret = srs_error_code(err);
srs_freep(err);
return ret;
} }
string path_tmp = tmppath(); string path_tmp = tmppath();
if ((ret = fw->open(path_tmp)) != ERROR_SUCCESS) { if ((err = fw->open(path_tmp)) != srs_success) {
srs_error("DASH: Open fmp4 failed, path=%s, ret=%d", path_tmp.c_str(), ret); return srs_error_wrap(err, "Open fmp4 failed, path=%s", path_tmp.c_str());
return ret;
} }
if ((ret = enc->initialize(fw, (uint32_t)sequence_number, basetime, tid)) != ERROR_SUCCESS) { if ((err = enc->initialize(fw, (uint32_t)sequence_number, basetime, tid)) != srs_success) {
return ret; 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()) { if (shared_msg->is_audio()) {
uint8_t* sample = (uint8_t*)format->raw; uint8_t* sample = (uint8_t*)format->raw;
uint32_t nb_sample = (uint32_t)format->nb_raw; uint32_t nb_sample = (uint32_t)format->nb_raw;
uint32_t dts = (uint32_t)shared_msg->timestamp; 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()) { } else if (shared_msg->is_video()) {
SrsVideoAvcFrameType frame_type = format->video->frame_type; SrsVideoAvcFrameType frame_type = format->video->frame_type;
uint32_t cts = (uint32_t)format->video->cts; 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; uint8_t* sample = (uint8_t*)format->raw;
uint32_t nb_sample = (uint32_t)format->nb_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 { } else {
return ret; return err;
} }
append(shared_msg->timestamp); 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; srs_error_t err = srs_success;
if ((ret = enc->flush(dts)) != ERROR_SUCCESS) { if ((err = enc->flush(dts)) != srs_success) {
srs_error("DASH: Flush encoder failed, ret=%d", ret); return srs_error_wrap(err, "Flush encoder failed");
return ret;
} }
srs_freep(fw); srs_freep(fw);
if ((err = rename()) != srs_success) { if ((err = rename()) != srs_success) {
// TODO: FIXME: Use error return srs_error_wrap(err, "rename");
ret = srs_error_code(err);
srs_freep(err);
return ret;
} }
return ret; return err;
} }
SrsMpdWriter::SrsMpdWriter() SrsMpdWriter::SrsMpdWriter()
@ -196,14 +185,13 @@ srs_error_t SrsMpdWriter::initialize(SrsRequest* r)
return srs_success; 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; srs_error_t err = srs_success;
// MPD is not expired? // MPD is not expired?
if (last_update_mpd != -1 && srs_get_system_time_ms() - last_update_mpd < update_period) { 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(); 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; fragment_home = srs_path_dirname(mpd_path) + "/" + req->stream;
if ((err = srs_create_dir_recursively(full_home)) != srs_success) { if ((err = srs_create_dir_recursively(full_home)) != srs_success) {
// TODO: FIXME: Use error return srs_error_wrap(err, "Create MPD home failed, home=%s", full_home.c_str());
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;
} }
stringstream ss; stringstream ss;
@ -257,31 +241,27 @@ int SrsMpdWriter::write(SrsFormat* format)
SrsAutoFree(SrsFileWriter, fw); SrsAutoFree(SrsFileWriter, fw);
string full_path_tmp = full_path + ".tmp"; string full_path_tmp = full_path + ".tmp";
if ((ret = fw->open(full_path_tmp)) != ERROR_SUCCESS) { if ((err = fw->open(full_path_tmp)) != srs_success) {
srs_error("DASH: Open MPD file=%s failed, ret=%d", full_path_tmp.c_str(), ret); return srs_error_wrap(err, "Open MPD file=%s failed", full_path_tmp.c_str());
return ret;
} }
string content = ss.str(); string content = ss.str();
if ((ret = fw->write((void*)content.data(), content.length(), NULL)) != ERROR_SUCCESS) { if ((err = fw->write((void*)content.data(), content.length(), NULL)) != srs_success) {
srs_error("DASH: Write MPD file=%s failed, ret=%d", full_path.c_str(), ret); return srs_error_wrap(err, "Write MPD file=%s failed", full_path.c_str());
return ret;
} }
if (::rename(full_path_tmp.c_str(), full_path.c_str()) < 0) { if (::rename(full_path_tmp.c_str(), full_path.c_str()) < 0) {
ret = ERROR_DASH_WRITE_FAILED; return srs_error_new(ERROR_DASH_WRITE_FAILED, "Rename %s to %s failed", full_path_tmp.c_str(), full_path.c_str());
srs_error("DASH: Rename %s to %s failed, ret=%d", full_path_tmp.c_str(), full_path.c_str(), ret);
return ret;
} }
srs_trace("DASH: Refresh MPD success, size=%dB, file=%s", content.length(), 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; 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"; file_name = "audio-" + srs_int2str(sn) + ".m4s";
} }
return ret; return err;
} }
SrsDashController::SrsDashController() SrsDashController::SrsDashController()
@ -320,7 +300,6 @@ SrsDashController::~SrsDashController()
srs_error_t SrsDashController::initialize(SrsRequest* r) srs_error_t SrsDashController::initialize(SrsRequest* r)
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
req = r; req = r;
@ -335,125 +314,113 @@ srs_error_t SrsDashController::initialize(SrsRequest* r)
srs_freep(vcurrent); srs_freep(vcurrent);
vcurrent = new SrsFragmentedMp4(); vcurrent = new SrsFragmentedMp4();
if ((ret = vcurrent->initialize(req, true, mpd, video_tack_id)) != ERROR_SUCCESS) { if ((err = vcurrent->initialize(req, true, mpd, video_tack_id)) != srs_success) {
return srs_error_new(ret, "video fragment"); return srs_error_wrap(err, "video fragment");
} }
srs_freep(acurrent); srs_freep(acurrent);
acurrent = new SrsFragmentedMp4(); acurrent = new SrsFragmentedMp4();
if ((ret = acurrent->initialize(req, false, mpd, audio_track_id)) != ERROR_SUCCESS) { if ((err = acurrent->initialize(req, false, mpd, audio_track_id)) != srs_success) {
return srs_error_new(ret, "audio fragment"); return srs_error_wrap(err, "audio fragment");
} }
return err; 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()) { if (format->is_aac_sequence_header()) {
return refresh_init_mp4(shared_audio, format); return refresh_init_mp4(shared_audio, format);
} }
if (acurrent->duration() >= fragment) { if (acurrent->duration() >= fragment) {
if ((ret = acurrent->reap(audio_dts)) != ERROR_SUCCESS) { if ((err = acurrent->reap(audio_dts)) != srs_success) {
return ret; return srs_error_wrap(err, "reap current");
} }
afragments->append(acurrent); afragments->append(acurrent);
acurrent = new SrsFragmentedMp4(); acurrent = new SrsFragmentedMp4();
if ((ret = acurrent->initialize(req, false, mpd, audio_track_id)) != ERROR_SUCCESS) { if ((err = acurrent->initialize(req, false, mpd, audio_track_id)) != srs_success) {
srs_error("DASH: Initialize the audio fragment failed, ret=%d", ret); return srs_error_wrap(err, "Initialize the audio fragment failed");
return ret;
} }
} }
if ((ret = acurrent->write(shared_audio, format)) != ERROR_SUCCESS) { if ((err = acurrent->write(shared_audio, format)) != srs_success) {
srs_error("DASH: Write audio to fragment failed, ret=%d", ret); return srs_error_wrap(err, "Write audio to fragment failed");
return ret;
} }
if ((ret = refresh_mpd(format)) != ERROR_SUCCESS) { if ((err = refresh_mpd(format)) != srs_success) {
srs_error("DASH: Refresh the MPD failed. ret=%d", ret); return srs_error_wrap(err, "Refresh the MPD failed");
return ret;
} }
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()) { if (format->is_avc_sequence_header()) {
return refresh_init_mp4(shared_video, format); return refresh_init_mp4(shared_video, format);
} }
bool reopen = format->video->frame_type == SrsVideoAvcFrameTypeKeyFrame bool reopen = format->video->frame_type == SrsVideoAvcFrameTypeKeyFrame && vcurrent->duration() >= fragment;
&& vcurrent->duration() >= fragment;
if (reopen) { if (reopen) {
if ((ret = vcurrent->reap(video_dts)) != ERROR_SUCCESS) { if ((err = vcurrent->reap(video_dts)) != srs_success) {
return ret; return srs_error_wrap(err, "reap current");
} }
vfragments->append(vcurrent); vfragments->append(vcurrent);
vcurrent = new SrsFragmentedMp4(); vcurrent = new SrsFragmentedMp4();
if ((ret = vcurrent->initialize(req, true, mpd, video_tack_id)) != ERROR_SUCCESS) { if ((err = vcurrent->initialize(req, true, mpd, video_tack_id)) != srs_success) {
srs_error("DASH: Initialize the video fragment failed, ret=%d", ret); return srs_error_wrap(err, "Initialize the video fragment failed");
return ret;
} }
} }
if ((ret = vcurrent->write(shared_video, format)) != ERROR_SUCCESS) { if ((err = vcurrent->write(shared_video, format)) != srs_success) {
srs_error("DASH: Write video to fragment failed, ret=%d", ret); return srs_error_wrap(err, "Write video to fragment failed");
return ret;
} }
if ((ret = refresh_mpd(format)) != ERROR_SUCCESS) { if ((err = refresh_mpd(format)) != srs_success) {
srs_error("DASH: Refresh the MPD failed. ret=%d", ret); return srs_error_wrap(err, "Refresh the MPD failed");
return ret;
} }
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. // TODO: FIXME: Support pure audio streaming.
if (!format->acodec || !format->vcodec) { if (!format->acodec || !format->vcodec) {
return ret; return err;
} }
if ((ret = mpd->write(format)) != ERROR_SUCCESS) { if ((err = mpd->write(format)) != srs_success) {
return ret; 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; srs_error_t err = srs_success;
if (msg->size <= 0 || (msg->is_video() && !format->vcodec->is_avc_codec_ok()) if (msg->size <= 0 || (msg->is_video() && !format->vcodec->is_avc_codec_ok())
|| (msg->is_audio() && !format->acodec->is_aac_codec_ok())) { || (msg->is_audio() && !format->acodec->is_aac_codec_ok())) {
srs_warn("DASH: Ignore empty sequence header."); srs_warn("DASH: Ignore empty sequence header.");
return ret; return err;
} }
string full_home = home + "/" + req->app + "/" + req->stream; string full_home = home + "/" + req->app + "/" + req->stream;
if ((err = srs_create_dir_recursively(full_home)) != srs_success) { if ((err = srs_create_dir_recursively(full_home)) != srs_success) {
// TODO: FIXME: Use error return srs_error_wrap(err, "Create media home failed, home=%s", full_home.c_str());
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;
} }
std::string path = full_home; std::string path = full_home;
@ -469,20 +436,17 @@ int SrsDashController::refresh_init_mp4(SrsSharedPtrMessage* msg, SrsFormat* for
init_mp4->set_path(path); init_mp4->set_path(path);
int tid = msg->is_video()? video_tack_id:audio_track_id; int tid = msg->is_video()? video_tack_id:audio_track_id;
if ((ret = init_mp4->write(format, msg->is_video(), tid)) != ERROR_SUCCESS) { if ((err = init_mp4->write(format, msg->is_video(), tid)) != srs_success) {
return ret; return srs_error_wrap(err, "write init");
} }
if ((err = init_mp4->rename()) != srs_success) { if ((err = init_mp4->rename()) != srs_success) {
// TODO: FIXME: Use error return srs_error_wrap(err, "rename init");
ret = srs_error_code(err);
srs_freep(err);
return ret;
} }
srs_trace("DASH: Refresh media success, file=%s", path.c_str()); srs_trace("DASH: Refresh media success, file=%s", path.c_str());
return ret; return err;
} }
SrsDash::SrsDash() SrsDash::SrsDash()
@ -513,53 +477,51 @@ srs_error_t SrsDash::initialize(SrsOriginHub* h, SrsRequest* r)
return err; 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. // Prevent duplicated publish.
if (enabled) { if (enabled) {
return ret; return err;
} }
if (!_srs_config->get_dash_enabled(req->vhost)) { if (!_srs_config->get_dash_enabled(req->vhost)) {
return ret; return err;
} }
enabled = true; 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) { if (!enabled) {
return ret; return err;
} }
if ((ret = controller->on_audio(shared_audio, format)) != ERROR_SUCCESS) { if ((err = controller->on_audio(shared_audio, format)) != srs_success) {
srs_error("DASH: Consume audio failed. ret=%d", ret); return srs_error_wrap(err, "Consume audio failed");
return ret;
} }
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) { if (!enabled) {
return ret; return err;
} }
if ((ret = controller->on_video(shared_video, format)) != ERROR_SUCCESS) { if ((err = controller->on_video(shared_video, format)) != srs_success) {
srs_error("DASH: Consume video failed. ret=%d", ret); return srs_error_wrap(err, "Consume video failed");
return ret;
} }
return ret; return err;
} }
void SrsDash::on_unpublish() 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() srs_error_t SrsDvrSegmenter::open()
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
// ignore when already open. // ignore when already open.
@ -108,8 +107,8 @@ srs_error_t SrsDvrSegmenter::open()
// open file writer, in append or create mode. // open file writer, in append or create mode.
string tmp_dvr_file = fragment->tmppath(); string tmp_dvr_file = fragment->tmppath();
if ((ret = fs->open(tmp_dvr_file)) != ERROR_SUCCESS) { if ((err = fs->open(tmp_dvr_file)) != srs_success) {
return srs_error_new(ret, "open file %s", path.c_str()); return srs_error_wrap(err, "open file %s", path.c_str());
} }
// initialize the encoder. // initialize the encoder.
@ -256,7 +255,6 @@ SrsDvrFlvSegmenter::~SrsDvrFlvSegmenter()
srs_error_t SrsDvrFlvSegmenter::refresh_metadata() srs_error_t SrsDvrFlvSegmenter::refresh_metadata()
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
// no duration or filesize specified. // no duration or filesize specified.
@ -270,24 +268,21 @@ srs_error_t SrsDvrFlvSegmenter::refresh_metadata()
char* buf = new char[SrsAmf0Size::number()]; char* buf = new char[SrsAmf0Size::number()];
SrsAutoFreeA(char, buf); SrsAutoFreeA(char, buf);
SrsBuffer stream; SrsBuffer stream(buf, SrsAmf0Size::number());
if ((ret = stream.initialize(buf, SrsAmf0Size::number())) != ERROR_SUCCESS) {
return srs_error_new(ret, "init stream");
}
// filesize to buf. // filesize to buf.
SrsAmf0Any* size = SrsAmf0Any::number((double)cur); SrsAmf0Any* size = SrsAmf0Any::number((double)cur);
SrsAutoFree(SrsAmf0Any, size); SrsAutoFree(SrsAmf0Any, size);
stream.skip(-1 * stream.pos()); stream.skip(-1 * stream.pos());
if ((ret = size->write(&stream)) != ERROR_SUCCESS) { if ((err = size->write(&stream)) != srs_success) {
return srs_error_new(ret, "write filesize"); return srs_error_wrap(err, "write filesize");
} }
// update the flesize. // update the flesize.
fs->seek2(filesize_offset); fs->seek2(filesize_offset);
if ((ret = fs->write(buf, SrsAmf0Size::number(), NULL)) != ERROR_SUCCESS) { if ((err = fs->write(buf, SrsAmf0Size::number(), NULL)) != srs_success) {
return srs_error_new(ret, "update filesize"); return srs_error_wrap(err, "update filesize");
} }
// duration to buf // duration to buf
@ -295,14 +290,14 @@ srs_error_t SrsDvrFlvSegmenter::refresh_metadata()
SrsAutoFree(SrsAmf0Any, dur); SrsAutoFree(SrsAmf0Any, dur);
stream.skip(-1 * stream.pos()); stream.skip(-1 * stream.pos());
if ((ret = dur->write(&stream)) != ERROR_SUCCESS) { if ((err = dur->write(&stream)) != srs_success) {
return srs_error_new(ret, "write duration"); return srs_error_wrap(err, "write duration");
} }
// update the duration // update the duration
fs->seek2(duration_offset); fs->seek2(duration_offset);
if ((ret = fs->write(buf, SrsAmf0Size::number(), NULL)) != ERROR_SUCCESS) { if ((err = fs->write(buf, SrsAmf0Size::number(), NULL)) != srs_success) {
return srs_error_new(ret, "update duration"); return srs_error_wrap(err, "update duration");
} }
// reset the offset. // reset the offset.
@ -313,7 +308,6 @@ srs_error_t SrsDvrFlvSegmenter::refresh_metadata()
srs_error_t SrsDvrFlvSegmenter::open_encoder() srs_error_t SrsDvrFlvSegmenter::open_encoder()
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
has_keyframe = false; has_keyframe = false;
@ -325,13 +319,13 @@ srs_error_t SrsDvrFlvSegmenter::open_encoder()
srs_freep(enc); srs_freep(enc);
enc = new SrsFlvTransmuxer(); enc = new SrsFlvTransmuxer();
if ((ret = enc->initialize(fs)) != ERROR_SUCCESS) { if ((err = enc->initialize(fs)) != srs_success) {
return srs_error_new(ret, "init encoder"); return srs_error_wrap(err, "init encoder");
} }
// write the flv header to writer. // write the flv header to writer.
if ((ret = enc->write_header()) != ERROR_SUCCESS) { if ((err = enc->write_header()) != srs_success) {
return srs_error_new(ret, "write flv header"); return srs_error_wrap(err, "write flv header");
} }
return err; return err;
@ -339,29 +333,25 @@ srs_error_t SrsDvrFlvSegmenter::open_encoder()
srs_error_t SrsDvrFlvSegmenter::encode_metadata(SrsSharedPtrMessage* metadata) srs_error_t SrsDvrFlvSegmenter::encode_metadata(SrsSharedPtrMessage* metadata)
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
// Ignore when metadata already written. // Ignore when metadata already written.
if (duration_offset || filesize_offset) { if (duration_offset || filesize_offset) {
return err; return err;
} }
SrsBuffer stream; SrsBuffer stream(metadata->payload, metadata->size);
if ((ret = stream.initialize(metadata->payload, metadata->size)) != ERROR_SUCCESS) {
return srs_error_new(ret, "init stream");
}
SrsAmf0Any* name = SrsAmf0Any::str(); SrsAmf0Any* name = SrsAmf0Any::str();
SrsAutoFree(SrsAmf0Any, name); SrsAutoFree(SrsAmf0Any, name);
if ((ret = name->read(&stream)) != ERROR_SUCCESS) { if ((err = name->read(&stream)) != srs_success) {
return srs_error_new(ret, "read name"); return srs_error_wrap(err, "read name");
} }
SrsAmf0Object* obj = SrsAmf0Any::object(); SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj); SrsAutoFree(SrsAmf0Object, obj);
if ((ret = obj->read(&stream)) != ERROR_SUCCESS) { if ((err = obj->read(&stream)) != srs_success) {
return srs_error_new(ret, "read object"); return srs_error_wrap(err, "read object");
} }
// remove duration and filesize. // 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(); filesize_offset = duration_offset - SrsAmf0Size::utf8("duration") - SrsAmf0Size::number();
// convert metadata to bytes. // convert metadata to bytes.
if ((ret = stream.initialize(payload, size)) != ERROR_SUCCESS) { SrsBuffer buf(payload, size);
return srs_error_new(ret, "init stream");
if ((err = name->write(&buf)) != srs_success) {
return srs_error_wrap(err, "write name");
} }
if ((ret = name->write(&stream)) != ERROR_SUCCESS) { if ((err = obj->write(&buf)) != srs_success) {
return srs_error_new(ret, "write name"); return srs_error_wrap(err, "write object");
}
if ((ret = obj->write(&stream)) != ERROR_SUCCESS) {
return srs_error_new(ret, "write object");
} }
// to flv file. // to flv file.
if ((ret = enc->write_metadata(18, payload, size)) != ERROR_SUCCESS) { if ((err = enc->write_metadata(18, payload, size)) != srs_success) {
return srs_error_new(ret, "write metadata"); return srs_error_wrap(err, "write metadata");
} }
return err; return err;
@ -403,13 +392,12 @@ srs_error_t SrsDvrFlvSegmenter::encode_metadata(SrsSharedPtrMessage* metadata)
srs_error_t SrsDvrFlvSegmenter::encode_audio(SrsSharedPtrMessage* audio, SrsFormat* format) srs_error_t SrsDvrFlvSegmenter::encode_audio(SrsSharedPtrMessage* audio, SrsFormat* format)
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
char* payload = audio->payload; char* payload = audio->payload;
int size = audio->size; int size = audio->size;
if ((ret = enc->write_audio(audio->timestamp, payload, size)) != ERROR_SUCCESS) { if ((err = enc->write_audio(audio->timestamp, payload, size)) != srs_success) {
return srs_error_new(ret, "write audio"); return srs_error_wrap(err, "write audio");
} }
return err; 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) srs_error_t SrsDvrFlvSegmenter::encode_video(SrsSharedPtrMessage* video, SrsFormat* format)
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
char* payload = video->payload; char* payload = video->payload;
@ -435,8 +422,8 @@ srs_error_t SrsDvrFlvSegmenter::encode_video(SrsSharedPtrMessage* video, SrsForm
return err; return err;
} }
if ((ret = enc->write_video(video->timestamp, payload, size)) != ERROR_SUCCESS) { if ((err = enc->write_video(video->timestamp, payload, size)) != srs_success) {
return srs_error_new(ret, "write video"); return srs_error_wrap(err, "write video");
} }
return err; return err;
@ -464,14 +451,13 @@ srs_error_t SrsDvrMp4Segmenter::refresh_metadata()
srs_error_t SrsDvrMp4Segmenter::open_encoder() srs_error_t SrsDvrMp4Segmenter::open_encoder()
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
srs_freep(enc); srs_freep(enc);
enc = new SrsMp4Encoder(); enc = new SrsMp4Encoder();
if ((ret = enc->initialize(fs)) != ERROR_SUCCESS) { if ((err = enc->initialize(fs)) != srs_success) {
return srs_error_new(ret, "init encoder"); return srs_error_wrap(err, "init encoder");
} }
return err; return err;
@ -484,7 +470,6 @@ srs_error_t SrsDvrMp4Segmenter::encode_metadata(SrsSharedPtrMessage* /*metadata*
srs_error_t SrsDvrMp4Segmenter::encode_audio(SrsSharedPtrMessage* audio, SrsFormat* format) srs_error_t SrsDvrMp4Segmenter::encode_audio(SrsSharedPtrMessage* audio, SrsFormat* format)
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
SrsAudioCodecId sound_format = format->acodec->id; 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 nb_sample = (uint32_t)format->nb_raw;
uint32_t dts = (uint32_t)audio->timestamp; uint32_t dts = (uint32_t)audio->timestamp;
if ((ret = enc->write_sample(SrsMp4HandlerTypeSOUN, 0x00, ct, dts, dts, sample, nb_sample)) != ERROR_SUCCESS) { if ((err = enc->write_sample(SrsMp4HandlerTypeSOUN, 0x00, ct, dts, dts, sample, nb_sample)) != srs_success) {
return srs_error_new(ret, "write sample"); return srs_error_wrap(err, "write sample");
} }
return err; 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) srs_error_t SrsDvrMp4Segmenter::encode_video(SrsSharedPtrMessage* video, SrsFormat* format)
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
SrsVideoAvcFrameType frame_type = format->video->frame_type; 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; uint8_t* sample = (uint8_t*)format->raw;
uint32_t nb_sample = (uint32_t)format->nb_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) { if ((err = enc->write_sample(SrsMp4HandlerTypeVIDE, frame_type, ct, dts, pts, sample, nb_sample)) != srs_success) {
return srs_error_new(ret, "write sample"); return srs_error_wrap(err, "write sample");
} }
return err; return err;
@ -540,11 +524,10 @@ srs_error_t SrsDvrMp4Segmenter::encode_video(SrsSharedPtrMessage* video, SrsForm
srs_error_t SrsDvrMp4Segmenter::close_encoder() srs_error_t SrsDvrMp4Segmenter::close_encoder()
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
if ((ret = enc->flush()) != ERROR_SUCCESS) { if ((err = enc->flush()) != srs_success) {
return srs_error_new(ret, "flush encoder"); return srs_error_wrap(err, "flush encoder");
} }
return err; return err;

48
trunk/src/libs/srs_lib_bandwidth.cpp
View file

@ -65,11 +65,14 @@ bool _bandwidth_is_finish(SrsBandwidthPacket* pkt)
int _srs_expect_bandwidth_packet(SrsRtmpClient* rtmp, _CheckPacketType pfn) int _srs_expect_bandwidth_packet(SrsRtmpClient* rtmp, _CheckPacketType pfn)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
while (true) { while (true) {
SrsCommonMessage* msg = NULL; SrsCommonMessage* msg = NULL;
SrsBandwidthPacket* pkt = NULL; SrsBandwidthPacket* pkt = NULL;
if ((ret = rtmp->expect_message<SrsBandwidthPacket>(&msg, &pkt)) != ERROR_SUCCESS) { if ((err = rtmp->expect_message<SrsBandwidthPacket>(&msg, &pkt)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
SrsAutoFree(SrsCommonMessage, msg); SrsAutoFree(SrsCommonMessage, msg);
@ -86,11 +89,14 @@ int _srs_expect_bandwidth_packet(SrsRtmpClient* rtmp, _CheckPacketType pfn)
int _srs_expect_bandwidth_packet2(SrsRtmpClient* rtmp, _CheckPacketType pfn, SrsBandwidthPacket** ppkt) int _srs_expect_bandwidth_packet2(SrsRtmpClient* rtmp, _CheckPacketType pfn, SrsBandwidthPacket** ppkt)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
while (true) { while (true) {
SrsCommonMessage* msg = NULL; SrsCommonMessage* msg = NULL;
SrsBandwidthPacket* pkt = NULL; SrsBandwidthPacket* pkt = NULL;
if ((ret = rtmp->expect_message<SrsBandwidthPacket>(&msg, &pkt)) != ERROR_SUCCESS) { if ((err = rtmp->expect_message<SrsBandwidthPacket>(&msg, &pkt)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
SrsAutoFree(SrsCommonMessage, msg); SrsAutoFree(SrsCommonMessage, msg);
@ -159,7 +165,7 @@ int SrsBandwidthClient::bandwidth_check(
} }
SrsBandwidthPacket* pkt = NULL; SrsBandwidthPacket* pkt = NULL;
if ((ret = final(&pkt)) != ERROR_SUCCESS) { if ((ret = do_final(&pkt)) != ERROR_SUCCESS) {
return ret; return ret;
} }
SrsAutoFree(SrsBandwidthPacket, pkt); SrsAutoFree(SrsBandwidthPacket, pkt);
@ -196,6 +202,7 @@ int SrsBandwidthClient::bandwidth_check(
int SrsBandwidthClient::play_start() int SrsBandwidthClient::play_start()
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if ((ret = _srs_expect_bandwidth_packet(_rtmp, _bandwidth_is_start_play)) != ERROR_SUCCESS) { if ((ret = _srs_expect_bandwidth_packet(_rtmp, _bandwidth_is_start_play)) != ERROR_SUCCESS) {
return ret; return ret;
@ -206,7 +213,9 @@ int SrsBandwidthClient::play_start()
// send start play response to server. // send start play response to server.
SrsBandwidthPacket* pkt = SrsBandwidthPacket::create_starting_play(); SrsBandwidthPacket* pkt = SrsBandwidthPacket::create_starting_play();
if ((ret = _rtmp->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) { if ((err = _rtmp->send_and_free_packet(pkt, 0)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
srs_error("send bandwidth check start play message failed. ret=%d", ret); srs_error("send bandwidth check start play message failed. ret=%d", ret);
return ret; return ret;
} }
@ -225,6 +234,7 @@ int SrsBandwidthClient::play_checking()
int SrsBandwidthClient::play_stop() int SrsBandwidthClient::play_stop()
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if ((ret = _srs_expect_bandwidth_packet(_rtmp, _bandwidth_is_stop_play)) != ERROR_SUCCESS) { if ((ret = _srs_expect_bandwidth_packet(_rtmp, _bandwidth_is_stop_play)) != ERROR_SUCCESS) {
return ret; return ret;
@ -235,7 +245,9 @@ int SrsBandwidthClient::play_stop()
// send stop play response to server. // send stop play response to server.
SrsBandwidthPacket* pkt = SrsBandwidthPacket::create_stopped_play(); SrsBandwidthPacket* pkt = SrsBandwidthPacket::create_stopped_play();
if ((ret = _rtmp->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) { if ((err = _rtmp->send_and_free_packet(pkt, 0)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
srs_error("send bandwidth check stop play message failed. ret=%d", ret); srs_error("send bandwidth check stop play message failed. ret=%d", ret);
return ret; return ret;
} }
@ -248,6 +260,7 @@ int SrsBandwidthClient::play_stop()
int SrsBandwidthClient::publish_start(int& duration_ms, int& play_kbps) int SrsBandwidthClient::publish_start(int& duration_ms, int& play_kbps)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (true) { if (true) {
SrsBandwidthPacket* pkt = NULL; SrsBandwidthPacket* pkt = NULL;
@ -270,7 +283,9 @@ int SrsBandwidthClient::publish_start(int& duration_ms, int& play_kbps)
// send start publish response to server. // send start publish response to server.
SrsBandwidthPacket* pkt = SrsBandwidthPacket::create_starting_publish(); SrsBandwidthPacket* pkt = SrsBandwidthPacket::create_starting_publish();
if ((ret = _rtmp->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) { if ((err = _rtmp->send_and_free_packet(pkt, 0)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
srs_error("send bandwidth check start publish message failed. ret=%d", ret); srs_error("send bandwidth check start publish message failed. ret=%d", ret);
return ret; return ret;
} }
@ -283,6 +298,7 @@ int SrsBandwidthClient::publish_start(int& duration_ms, int& play_kbps)
int SrsBandwidthClient::publish_checking(int duration_ms, int play_kbps) int SrsBandwidthClient::publish_checking(int duration_ms, int play_kbps)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (duration_ms <= 0) { if (duration_ms <= 0) {
ret = ERROR_RTMP_BWTC_DATA; ret = ERROR_RTMP_BWTC_DATA;
@ -312,7 +328,9 @@ int SrsBandwidthClient::publish_checking(int duration_ms, int play_kbps)
} }
data_count += 2; data_count += 2;
if ((ret = _rtmp->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) { if ((err = _rtmp->send_and_free_packet(pkt, 0)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
srs_error("send bandwidth check publish messages failed. ret=%d", ret); srs_error("send bandwidth check publish messages failed. ret=%d", ret);
return ret; return ret;
} }
@ -338,12 +356,15 @@ int SrsBandwidthClient::publish_checking(int duration_ms, int play_kbps)
int SrsBandwidthClient::publish_stop() int SrsBandwidthClient::publish_stop()
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (true) { if (true) {
// send start publish response to server. // send start publish response to server.
SrsBandwidthPacket* pkt = SrsBandwidthPacket::create_stop_publish(); SrsBandwidthPacket* pkt = SrsBandwidthPacket::create_stop_publish();
if ((ret = _rtmp->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) { if ((err = _rtmp->send_and_free_packet(pkt, 0)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
srs_error("send bandwidth check stop publish message failed. ret=%d", ret); srs_error("send bandwidth check stop publish message failed. ret=%d", ret);
return ret; return ret;
} }
@ -359,7 +380,9 @@ int SrsBandwidthClient::publish_stop()
// send start publish response to server. // send start publish response to server.
SrsBandwidthPacket* pkt = SrsBandwidthPacket::create_stopped_publish(); SrsBandwidthPacket* pkt = SrsBandwidthPacket::create_stopped_publish();
if ((ret = _rtmp->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) { if ((err = _rtmp->send_and_free_packet(pkt, 0)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
srs_error("send bandwidth check stop publish message failed. ret=%d", ret); srs_error("send bandwidth check stop publish message failed. ret=%d", ret);
return ret; return ret;
} }
@ -369,9 +392,10 @@ int SrsBandwidthClient::publish_stop()
return ret; return ret;
} }
int SrsBandwidthClient::final(SrsBandwidthPacket** ppkt) int SrsBandwidthClient::do_final(SrsBandwidthPacket** ppkt)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if ((ret = _srs_expect_bandwidth_packet2(_rtmp, _bandwidth_is_finish, ppkt)) != ERROR_SUCCESS) { if ((ret = _srs_expect_bandwidth_packet2(_rtmp, _bandwidth_is_finish, ppkt)) != ERROR_SUCCESS) {
return ret; return ret;
@ -382,7 +406,9 @@ int SrsBandwidthClient::final(SrsBandwidthPacket** ppkt)
// send final response to server. // send final response to server.
SrsBandwidthPacket* pkt = SrsBandwidthPacket::create_final(); SrsBandwidthPacket* pkt = SrsBandwidthPacket::create_final();
if ((ret = _rtmp->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) { if ((err = _rtmp->send_and_free_packet(pkt, 0)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
srs_error("send bandwidth check final message failed. ret=%d", ret); srs_error("send bandwidth check final message failed. ret=%d", ret);
return ret; return ret;
} }

2
trunk/src/libs/srs_lib_bandwidth.hpp
View file

@ -78,7 +78,7 @@ private:
/** /**
* report and final packet * report and final packet
*/ */
virtual int final(SrsBandwidthPacket** ppkt); virtual int do_final(SrsBandwidthPacket** ppkt);
}; };
#endif #endif

32
trunk/src/libs/srs_lib_simple_socket.cpp
View file

@ -342,10 +342,14 @@ int SimpleSocketStream::connect(const char* server_ip, int port)
} }
// ISrsReader // ISrsReader
int SimpleSocketStream::read(void* buf, size_t size, ssize_t* nread) srs_error_t SimpleSocketStream::read(void* buf, size_t size, ssize_t* nread)
{ {
srs_assert(io); srs_assert(io);
return srs_hijack_io_read(io, buf, size, nread); int ret = srs_hijack_io_read(io, buf, size, nread);
if (ret != ERROR_SUCCESS) {
return srs_error_new(ret, "read");
}
return srs_success;
} }
// ISrsProtocolReader // ISrsProtocolReader
@ -386,10 +390,14 @@ int64_t SimpleSocketStream::get_send_bytes()
return srs_hijack_io_get_send_bytes(io); return srs_hijack_io_get_send_bytes(io);
} }
int SimpleSocketStream::writev(const iovec *iov, int iov_size, ssize_t* nwrite) srs_error_t SimpleSocketStream::writev(const iovec *iov, int iov_size, ssize_t* nwrite)
{ {
srs_assert(io); srs_assert(io);
return srs_hijack_io_writev(io, iov, iov_size, nwrite); int ret = srs_hijack_io_writev(io, iov, iov_size, nwrite);
if (ret != ERROR_SUCCESS) {
return srs_error_new(ret, "read");
}
return srs_success;
} }
// ISrsProtocolReaderWriter // ISrsProtocolReaderWriter
@ -399,16 +407,24 @@ bool SimpleSocketStream::is_never_timeout(int64_t tm)
return srs_hijack_io_is_never_timeout(io, tm); return srs_hijack_io_is_never_timeout(io, tm);
} }
int SimpleSocketStream::read_fully(void* buf, size_t size, ssize_t* nread) srs_error_t SimpleSocketStream::read_fully(void* buf, size_t size, ssize_t* nread)
{ {
srs_assert(io); srs_assert(io);
return srs_hijack_io_read_fully(io, buf, size, nread); int ret = srs_hijack_io_read_fully(io, buf, size, nread);
if (ret != ERROR_SUCCESS) {
return srs_error_new(ret, "read");
}
return srs_success;
} }
int SimpleSocketStream::write(void* buf, size_t size, ssize_t* nwrite) srs_error_t SimpleSocketStream::write(void* buf, size_t size, ssize_t* nwrite)
{ {
srs_assert(io); srs_assert(io);
return srs_hijack_io_write(io, buf, size, nwrite); int ret = srs_hijack_io_write(io, buf, size, nwrite);
if (ret != ERROR_SUCCESS) {
return srs_error_new(ret, "read");
}
return srs_success;
} }

16
trunk/src/libs/srs_lib_simple_socket.hpp
View file

@ -49,25 +49,25 @@ public:
virtual srs_hijack_io_t hijack_io(); virtual srs_hijack_io_t hijack_io();
virtual int create_socket(srs_rtmp_t owner); virtual int create_socket(srs_rtmp_t owner);
virtual int connect(const char* server, int port); virtual int connect(const char* server, int port);
// ISrsReader // ISrsReader
public: public:
virtual int read(void* buf, size_t size, ssize_t* nread); virtual srs_error_t read(void* buf, size_t size, ssize_t* nread);
// ISrsProtocolReader // ISrsProtocolReader
public: public:
virtual void set_recv_timeout(int64_t tm); virtual void set_recv_timeout(int64_t tm);
virtual int64_t get_recv_timeout(); virtual int64_t get_recv_timeout();
virtual int64_t get_recv_bytes(); virtual int64_t get_recv_bytes();
// ISrsProtocolWriter // ISrsProtocolWriter
public: public:
virtual void set_send_timeout(int64_t tm); virtual void set_send_timeout(int64_t tm);
virtual int64_t get_send_timeout(); virtual int64_t get_send_timeout();
virtual int64_t get_send_bytes(); virtual int64_t get_send_bytes();
virtual int writev(const iovec *iov, int iov_size, ssize_t* nwrite); virtual srs_error_t writev(const iovec *iov, int iov_size, ssize_t* nwrite);
// ISrsProtocolReaderWriter // ISrsProtocolReaderWriter
public: public:
virtual bool is_never_timeout(int64_t tm); virtual bool is_never_timeout(int64_t tm);
virtual int read_fully(void* buf, size_t size, ssize_t* nread); virtual srs_error_t read_fully(void* buf, size_t size, ssize_t* nread);
virtual int write(void* buf, size_t size, ssize_t* nwrite); virtual srs_error_t write(void* buf, size_t size, ssize_t* nwrite);
}; };
#endif #endif

248
trunk/src/libs/srs_librtmp.cpp
View file

@ -100,9 +100,6 @@ struct Context
SrsRawH264Stream avc_raw; SrsRawH264Stream avc_raw;
SrsRawAacStream aac_raw; SrsRawAacStream aac_raw;
// for h264 raw stream,
// @see: https://github.com/ossrs/srs/issues/66#issuecomment-62240521
SrsBuffer h264_raw_stream;
// about SPS, @see: 7.3.2.1.1, ISO_IEC_14496-10-AVC-2012.pdf, page 62 // about SPS, @see: 7.3.2.1.1, ISO_IEC_14496-10-AVC-2012.pdf, page 62
std::string h264_sps; std::string h264_sps;
std::string h264_pps; std::string h264_pps;
@ -113,9 +110,6 @@ struct Context
// @see https://github.com/ossrs/srs/issues/204 // @see https://github.com/ossrs/srs/issues/204
bool h264_sps_changed; bool h264_sps_changed;
bool h264_pps_changed; bool h264_pps_changed;
// for aac raw stream,
// @see: https://github.com/ossrs/srs/issues/212#issuecomment-64146250
SrsBuffer aac_raw_stream;
// the aac sequence header. // the aac sequence header.
std::string aac_specific_config; std::string aac_specific_config;
@ -666,6 +660,7 @@ extern "C"{
return ERROR_RTMP_HS_SSL_REQUIRE; return ERROR_RTMP_HS_SSL_REQUIRE;
#else #else
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
srs_assert(rtmp != NULL); srs_assert(rtmp != NULL);
Context* context = (Context*)rtmp; Context* context = (Context*)rtmp;
@ -676,7 +671,9 @@ extern "C"{
srs_freep(context->rtmp); srs_freep(context->rtmp);
context->rtmp = new SrsRtmpClient(context->skt); context->rtmp = new SrsRtmpClient(context->skt);
if ((ret = context->rtmp->complex_handshake()) != ERROR_SUCCESS) { if ((err = context->rtmp->complex_handshake()) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -687,6 +684,7 @@ extern "C"{
int srs_rtmp_do_simple_handshake(srs_rtmp_t rtmp) int srs_rtmp_do_simple_handshake(srs_rtmp_t rtmp)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
srs_assert(rtmp != NULL); srs_assert(rtmp != NULL);
Context* context = (Context*)rtmp; Context* context = (Context*)rtmp;
@ -697,16 +695,17 @@ extern "C"{
srs_freep(context->rtmp); srs_freep(context->rtmp);
context->rtmp = new SrsRtmpClient(context->skt); context->rtmp = new SrsRtmpClient(context->skt);
if ((ret = context->rtmp->simple_handshake()) != ERROR_SUCCESS) { if ((err = context->rtmp->simple_handshake()) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
return ret; return ret;
} }
int srs_rtmp_set_connect_args(srs_rtmp_t rtmp, int srs_rtmp_set_connect_args(srs_rtmp_t rtmp, const char* tcUrl, const char* swfUrl, const char* pageUrl, srs_amf0_t args)
const char* tcUrl, const char* swfUrl, const char* pageUrl, srs_amf0_t args {
) {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_assert(rtmp != NULL); srs_assert(rtmp != NULL);
@ -746,6 +745,7 @@ extern "C"{
int srs_rtmp_connect_app(srs_rtmp_t rtmp) int srs_rtmp_connect_app(srs_rtmp_t rtmp)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
srs_assert(rtmp != NULL); srs_assert(rtmp != NULL);
Context* context = (Context*)rtmp; Context* context = (Context*)rtmp;
@ -767,7 +767,9 @@ extern "C"{
} }
Context* c = context; Context* c = context;
if ((ret = context->rtmp->connect_app(c->app, tcUrl, c->req, true, &c->si)) != ERROR_SUCCESS) { if ((err = context->rtmp->connect_app(c->app, tcUrl, c->req, true, &c->si)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -812,14 +814,20 @@ extern "C"{
int srs_rtmp_play_stream(srs_rtmp_t rtmp) int srs_rtmp_play_stream(srs_rtmp_t rtmp)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
srs_assert(rtmp != NULL); srs_assert(rtmp != NULL);
Context* context = (Context*)rtmp; Context* context = (Context*)rtmp;
if ((ret = context->rtmp->create_stream(context->stream_id)) != ERROR_SUCCESS) { if ((err = context->rtmp->create_stream(context->stream_id)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
if ((ret = context->rtmp->play(context->stream, context->stream_id)) != ERROR_SUCCESS) {
if ((err = context->rtmp->play(context->stream, context->stream_id)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -829,11 +837,14 @@ extern "C"{
int srs_rtmp_publish_stream(srs_rtmp_t rtmp) int srs_rtmp_publish_stream(srs_rtmp_t rtmp)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
srs_assert(rtmp != NULL); srs_assert(rtmp != NULL);
Context* context = (Context*)rtmp; Context* context = (Context*)rtmp;
if ((ret = context->rtmp->fmle_publish(context->stream, context->stream_id)) != ERROR_SUCCESS) { if ((err = context->rtmp->fmle_publish(context->stream, context->stream_id)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -881,11 +892,8 @@ extern "C"{
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
SrsBuffer aggregate_stream; SrsBuffer* stream = new SrsBuffer(msg->payload, msg->size);
SrsBuffer* stream = &aggregate_stream; SrsAutoFree(SrsBuffer, stream);
if ((ret = stream->initialize(msg->payload, msg->size)) != ERROR_SUCCESS) {
return ret;
}
// the aggregate message always use abs time. // the aggregate message always use abs time.
int delta = -1; int delta = -1;
@ -1035,6 +1043,7 @@ extern "C"{
*size = 0; *size = 0;
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
srs_assert(rtmp != NULL); srs_assert(rtmp != NULL);
Context* context = (Context*)rtmp; Context* context = (Context*)rtmp;
@ -1050,7 +1059,9 @@ extern "C"{
} }
// read from protocol sdk. // read from protocol sdk.
if (!msg && (ret = context->rtmp->recv_message(&msg)) != ERROR_SUCCESS) { if (!msg && (err = context->rtmp->recv_message(&msg)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1079,20 +1090,25 @@ extern "C"{
int srs_rtmp_write_packet(srs_rtmp_t rtmp, char type, uint32_t timestamp, char* data, int size) int srs_rtmp_write_packet(srs_rtmp_t rtmp, char type, uint32_t timestamp, char* data, int size)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
srs_assert(rtmp != NULL); srs_assert(rtmp != NULL);
Context* context = (Context*)rtmp; Context* context = (Context*)rtmp;
SrsSharedPtrMessage* msg = NULL; SrsSharedPtrMessage* msg = NULL;
if ((ret = srs_rtmp_create_msg(type, timestamp, data, size, context->stream_id, &msg)) != ERROR_SUCCESS) { if ((err = srs_rtmp_create_msg(type, timestamp, data, size, context->stream_id, &msg)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
srs_assert(msg); srs_assert(msg);
// send out encoded msg. // send out encoded msg.
if ((ret = context->rtmp->send_and_free_message(msg, context->stream_id)) != ERROR_SUCCESS) { if ((err = context->rtmp->send_and_free_message(msg, context->stream_id)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1106,19 +1122,17 @@ extern "C"{
srs_bool srs_rtmp_is_onMetaData(char type, char* data, int size) srs_bool srs_rtmp_is_onMetaData(char type, char* data, int size)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
if (type != SRS_RTMP_TYPE_SCRIPT) { if (type != SRS_RTMP_TYPE_SCRIPT) {
return false; return false;
} }
SrsBuffer stream; SrsBuffer stream(data, size);
if ((ret = stream.initialize(data, size)) != ERROR_SUCCESS) {
return false;
}
std::string name; std::string name;
if ((ret = srs_amf0_read_string(&stream, name)) != ERROR_SUCCESS) { if ((err = srs_amf0_read_string(&stream, name)) != srs_success) {
srs_freep(err);
return false; return false;
} }
@ -1139,10 +1153,13 @@ extern "C"{
int srs_write_audio_raw_frame(Context* context, char* frame, int frame_size, SrsRawAacStreamCodec* codec, uint32_t timestamp) int srs_write_audio_raw_frame(Context* context, char* frame, int frame_size, SrsRawAacStreamCodec* codec, uint32_t timestamp)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
char* data = NULL; char* data = NULL;
int size = 0; int size = 0;
if ((ret = context->aac_raw.mux_aac2flv(frame, frame_size, codec, timestamp, &data, &size)) != ERROR_SUCCESS) { if ((err = context->aac_raw.mux_aac2flv(frame, frame_size, codec, timestamp, &data, &size)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1155,11 +1172,14 @@ extern "C"{
int srs_write_aac_adts_frame(Context* context, SrsRawAacStreamCodec* codec, char* frame, int frame_size, uint32_t timestamp) int srs_write_aac_adts_frame(Context* context, SrsRawAacStreamCodec* codec, char* frame, int frame_size, uint32_t timestamp)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// send out aac sequence header if not sent. // send out aac sequence header if not sent.
if (context->aac_specific_config.empty()) { if (context->aac_specific_config.empty()) {
std::string sh; std::string sh;
if ((ret = context->aac_raw.mux_sequence_header(codec, sh)) != ERROR_SUCCESS) { if ((err = context->aac_raw.mux_sequence_header(codec, sh)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
context->aac_specific_config = sh; context->aac_specific_config = sh;
@ -1182,17 +1202,18 @@ extern "C"{
char sound_size, char sound_type, char* frames, int frames_size, uint32_t timestamp char sound_size, char sound_type, char* frames, int frames_size, uint32_t timestamp
) { ) {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
SrsBuffer* stream = &context->aac_raw_stream; SrsBuffer* stream = new SrsBuffer(frames, frames_size);
if ((ret = stream->initialize(frames, frames_size)) != ERROR_SUCCESS) { SrsAutoFree(SrsBuffer, stream);
return ret;
}
while (!stream->empty()) { while (!stream->empty()) {
char* frame = NULL; char* frame = NULL;
int frame_size = 0; int frame_size = 0;
SrsRawAacStreamCodec codec; SrsRawAacStreamCodec codec;
if ((ret = context->aac_raw.adts_demux(stream, &frame, &frame_size, codec)) != ERROR_SUCCESS) { if ((err = context->aac_raw.adts_demux(stream, &frame, &frame_size, codec)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1251,12 +1272,7 @@ extern "C"{
*/ */
srs_bool srs_aac_is_adts(char* aac_raw_data, int ac_raw_size) srs_bool srs_aac_is_adts(char* aac_raw_data, int ac_raw_size)
{ {
SrsBuffer stream; SrsBuffer stream(aac_raw_data, ac_raw_size);
if (stream.initialize(aac_raw_data, ac_raw_size) != ERROR_SUCCESS) {
return false;
}
return srs_aac_startswith_adts(&stream); return srs_aac_startswith_adts(&stream);
} }
@ -1294,6 +1310,7 @@ extern "C"{
int srs_write_h264_ipb_frame(Context* context, char* frame, int frame_size, uint32_t dts, uint32_t pts) int srs_write_h264_ipb_frame(Context* context, char* frame, int frame_size, uint32_t dts, uint32_t pts)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// when sps or pps not sent, ignore the packet. // when sps or pps not sent, ignore the packet.
// @see https://github.com/ossrs/srs/issues/203 // @see https://github.com/ossrs/srs/issues/203
@ -1321,14 +1338,18 @@ extern "C"{
} }
std::string ibp; std::string ibp;
if ((ret = context->avc_raw.mux_ipb_frame(frame, frame_size, ibp)) != ERROR_SUCCESS) { if ((err = context->avc_raw.mux_ipb_frame(frame, frame_size, ibp)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
int8_t avc_packet_type = SrsVideoAvcFrameTraitNALU; int8_t avc_packet_type = SrsVideoAvcFrameTraitNALU;
char* flv = NULL; char* flv = NULL;
int nb_flv = 0; int nb_flv = 0;
if ((ret = context->avc_raw.mux_avc2flv(ibp, frame_type, avc_packet_type, dts, pts, &flv, &nb_flv)) != ERROR_SUCCESS) { if ((err = context->avc_raw.mux_avc2flv(ibp, frame_type, avc_packet_type, dts, pts, &flv, &nb_flv)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1343,6 +1364,7 @@ extern "C"{
int srs_write_h264_sps_pps(Context* context, uint32_t dts, uint32_t pts) int srs_write_h264_sps_pps(Context* context, uint32_t dts, uint32_t pts)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// send when sps or pps changed. // send when sps or pps changed.
if (!context->h264_sps_changed && !context->h264_pps_changed) { if (!context->h264_sps_changed && !context->h264_pps_changed) {
@ -1351,7 +1373,9 @@ extern "C"{
// h264 raw to h264 packet. // h264 raw to h264 packet.
std::string sh; std::string sh;
if ((ret = context->avc_raw.mux_sequence_header(context->h264_sps, context->h264_pps, dts, pts, sh)) != ERROR_SUCCESS) { if ((err = context->avc_raw.mux_sequence_header(context->h264_sps, context->h264_pps, dts, pts, sh)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1360,7 +1384,9 @@ extern "C"{
int8_t avc_packet_type = SrsVideoAvcFrameTraitSequenceHeader; int8_t avc_packet_type = SrsVideoAvcFrameTraitSequenceHeader;
char* flv = NULL; char* flv = NULL;
int nb_flv = 0; int nb_flv = 0;
if ((ret = context->avc_raw.mux_avc2flv(sh, frame_type, avc_packet_type, dts, pts, &flv, &nb_flv)) != ERROR_SUCCESS) { if ((err = context->avc_raw.mux_avc2flv(sh, frame_type, avc_packet_type, dts, pts, &flv, &nb_flv)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1380,6 +1406,7 @@ extern "C"{
int srs_write_h264_raw_frame(Context* context, char* frame, int frame_size, uint32_t dts, uint32_t pts) int srs_write_h264_raw_frame(Context* context, char* frame, int frame_size, uint32_t dts, uint32_t pts)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// empty frame. // empty frame.
if (frame_size <= 0) { if (frame_size <= 0) {
@ -1389,7 +1416,9 @@ extern "C"{
// for sps // for sps
if (context->avc_raw.is_sps(frame, frame_size)) { if (context->avc_raw.is_sps(frame, frame_size)) {
std::string sps; std::string sps;
if ((ret = context->avc_raw.sps_demux(frame, frame_size, sps)) != ERROR_SUCCESS) { if ((err = context->avc_raw.sps_demux(frame, frame_size, sps)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1405,7 +1434,9 @@ extern "C"{
// for pps // for pps
if (context->avc_raw.is_pps(frame, frame_size)) { if (context->avc_raw.is_pps(frame, frame_size)) {
std::string pps; std::string pps;
if ((ret = context->avc_raw.pps_demux(frame, frame_size, pps)) != ERROR_SUCCESS) { if ((err = context->avc_raw.pps_demux(frame, frame_size, pps)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1445,6 +1476,7 @@ extern "C"{
int srs_h264_write_raw_frames(srs_rtmp_t rtmp, char* frames, int frames_size, uint32_t dts, uint32_t pts) int srs_h264_write_raw_frames(srs_rtmp_t rtmp, char* frames, int frames_size, uint32_t dts, uint32_t pts)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
srs_assert(frames != NULL); srs_assert(frames != NULL);
srs_assert(frames_size > 0); srs_assert(frames_size > 0);
@ -1452,9 +1484,8 @@ extern "C"{
srs_assert(rtmp != NULL); srs_assert(rtmp != NULL);
Context* context = (Context*)rtmp; Context* context = (Context*)rtmp;
if ((ret = context->h264_raw_stream.initialize(frames, frames_size)) != ERROR_SUCCESS) { SrsBuffer* stream = new SrsBuffer(frames, frames_size);
return ret; SrsAutoFree(SrsBuffer, stream);
}
// use the last error // use the last error
// @see https://github.com/ossrs/srs/issues/203 // @see https://github.com/ossrs/srs/issues/203
@ -1462,10 +1493,12 @@ extern "C"{
int error_code_return = ret; int error_code_return = ret;
// send each frame. // send each frame.
while (!context->h264_raw_stream.empty()) { while (!stream->empty()) {
char* frame = NULL; char* frame = NULL;
int frame_size = 0; int frame_size = 0;
if ((ret = context->avc_raw.annexb_demux(&context->h264_raw_stream, &frame, &frame_size)) != ERROR_SUCCESS) { if ((err = context->avc_raw.annexb_demux(stream, &frame, &frame_size)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1511,11 +1544,7 @@ extern "C"{
srs_bool srs_h264_startswith_annexb(char* h264_raw_data, int h264_raw_size, int* pnb_start_code) srs_bool srs_h264_startswith_annexb(char* h264_raw_data, int h264_raw_size, int* pnb_start_code)
{ {
SrsBuffer stream; SrsBuffer stream(h264_raw_data, h264_raw_size);
if (stream.initialize(h264_raw_data, h264_raw_size) != ERROR_SUCCESS) {
return false;
}
return srs_avc_startswith_annexb(&stream, pnb_start_code); return srs_avc_startswith_annexb(&stream, pnb_start_code);
} }
@ -1528,10 +1557,13 @@ extern "C"{
srs_mp4_t srs_mp4_open_read(const char* file) srs_mp4_t srs_mp4_open_read(const char* file)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
Mp4Context* mp4 = new Mp4Context(); Mp4Context* mp4 = new Mp4Context();
if ((ret = mp4->reader.open(file)) != ERROR_SUCCESS) { if ((err = mp4->reader.open(file)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
srs_human_error("Open MP4 file failed, ret=%d", ret); srs_human_error("Open MP4 file failed, ret=%d", ret);
srs_freep(mp4); srs_freep(mp4);
@ -1550,10 +1582,13 @@ extern "C"{
int srs_mp4_init_demuxer(srs_mp4_t mp4) int srs_mp4_init_demuxer(srs_mp4_t mp4)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
Mp4Context* context = (Mp4Context*)mp4; Mp4Context* context = (Mp4Context*)mp4;
if ((ret = context->dec.initialize(&context->reader)) != ERROR_SUCCESS) { if ((err = context->dec.initialize(&context->reader)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1565,12 +1600,15 @@ extern "C"{
s->sample = NULL; s->sample = NULL;
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
Mp4Context* context = (Mp4Context*)mp4; Mp4Context* context = (Mp4Context*)mp4;
SrsMp4Decoder* dec = &context->dec; SrsMp4Decoder* dec = &context->dec;
SrsMp4HandlerType ht = SrsMp4HandlerTypeForbidden; SrsMp4HandlerType ht = SrsMp4HandlerTypeForbidden;
if ((ret = dec->read_sample(&ht, &s->frame_type, &s->frame_trait, &s->dts, &s->pts, &s->sample, &s->nb_sample)) != ERROR_SUCCESS) { if ((err = dec->read_sample(&ht, &s->frame_type, &s->frame_trait, &s->dts, &s->pts, &s->sample, &s->nb_sample)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1662,17 +1700,22 @@ extern "C"{
srs_flv_t srs_flv_open_read(const char* file) srs_flv_t srs_flv_open_read(const char* file)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
FlvContext* flv = new FlvContext(); FlvContext* flv = new FlvContext();
if ((ret = flv->reader.open(file)) != ERROR_SUCCESS) { if ((err = flv->reader.open(file)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
srs_human_error("Open FLV file failed, ret=%d", ret); srs_human_error("Open FLV file failed, ret=%d", ret);
srs_freep(flv); srs_freep(flv);
return NULL; return NULL;
} }
if ((ret = flv->dec.initialize(&flv->reader)) != ERROR_SUCCESS) { if ((err = flv->dec.initialize(&flv->reader)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
srs_human_error("Initialize FLV demuxer failed, ret=%d", ret); srs_human_error("Initialize FLV demuxer failed, ret=%d", ret);
srs_freep(flv); srs_freep(flv);
@ -1685,17 +1728,22 @@ extern "C"{
srs_flv_t srs_flv_open_write(const char* file) srs_flv_t srs_flv_open_write(const char* file)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
FlvContext* flv = new FlvContext(); FlvContext* flv = new FlvContext();
if ((ret = flv->writer.open(file)) != ERROR_SUCCESS) { if ((err = flv->writer.open(file)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
srs_human_error("Open FLV file failed, ret=%d", ret); srs_human_error("Open FLV file failed, ret=%d", ret);
srs_freep(flv); srs_freep(flv);
return NULL; return NULL;
} }
if ((ret = flv->enc.initialize(&flv->writer)) != ERROR_SUCCESS) { if ((err = flv->enc.initialize(&flv->writer)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
srs_human_error("Initilize FLV muxer failed, ret=%d", ret); srs_human_error("Initilize FLV muxer failed, ret=%d", ret);
srs_freep(flv); srs_freep(flv);
@ -1714,6 +1762,7 @@ extern "C"{
int srs_flv_read_header(srs_flv_t flv, char header[9]) int srs_flv_read_header(srs_flv_t flv, char header[9])
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
FlvContext* context = (FlvContext*)flv; FlvContext* context = (FlvContext*)flv;
@ -1721,12 +1770,16 @@ extern "C"{
return ERROR_SYSTEM_IO_INVALID; return ERROR_SYSTEM_IO_INVALID;
} }
if ((ret = context->dec.read_header(header)) != ERROR_SUCCESS) { if ((err = context->dec.read_header(header)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
char ts[4]; // tag size char ts[4]; // tag size
if ((ret = context->dec.read_previous_tag_size(ts)) != ERROR_SUCCESS) { if ((err = context->dec.read_previous_tag_size(ts)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1736,6 +1789,7 @@ extern "C"{
int srs_flv_read_tag_header(srs_flv_t flv, char* ptype, int32_t* pdata_size, uint32_t* ptime) int srs_flv_read_tag_header(srs_flv_t flv, char* ptype, int32_t* pdata_size, uint32_t* ptime)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
FlvContext* context = (FlvContext*)flv; FlvContext* context = (FlvContext*)flv;
@ -1743,7 +1797,9 @@ extern "C"{
return ERROR_SYSTEM_IO_INVALID; return ERROR_SYSTEM_IO_INVALID;
} }
if ((ret = context->dec.read_tag_header(ptype, pdata_size, ptime)) != ERROR_SUCCESS) { if ((err = context->dec.read_tag_header(ptype, pdata_size, ptime)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1753,6 +1809,7 @@ extern "C"{
int srs_flv_read_tag_data(srs_flv_t flv, char* data, int32_t size) int srs_flv_read_tag_data(srs_flv_t flv, char* data, int32_t size)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
FlvContext* context = (FlvContext*)flv; FlvContext* context = (FlvContext*)flv;
@ -1760,12 +1817,16 @@ extern "C"{
return ERROR_SYSTEM_IO_INVALID; return ERROR_SYSTEM_IO_INVALID;
} }
if ((ret = context->dec.read_tag_data(data, size)) != ERROR_SUCCESS) { if ((err = context->dec.read_tag_data(data, size)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
char ts[4]; // tag size char ts[4]; // tag size
if ((ret = context->dec.read_previous_tag_size(ts)) != ERROR_SUCCESS) { if ((err = context->dec.read_previous_tag_size(ts)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1775,6 +1836,7 @@ extern "C"{
int srs_flv_write_header(srs_flv_t flv, char header[9]) int srs_flv_write_header(srs_flv_t flv, char header[9])
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
FlvContext* context = (FlvContext*)flv; FlvContext* context = (FlvContext*)flv;
@ -1782,7 +1844,9 @@ extern "C"{
return ERROR_SYSTEM_IO_INVALID; return ERROR_SYSTEM_IO_INVALID;
} }
if ((ret = context->enc.write_header(header)) != ERROR_SUCCESS) { if ((err = context->enc.write_header(header)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1792,6 +1856,7 @@ extern "C"{
int srs_flv_write_tag(srs_flv_t flv, char type, int32_t time, char* data, int size) int srs_flv_write_tag(srs_flv_t flv, char type, int32_t time, char* data, int size)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
FlvContext* context = (FlvContext*)flv; FlvContext* context = (FlvContext*)flv;
@ -1800,11 +1865,23 @@ extern "C"{
} }
if (type == SRS_RTMP_TYPE_AUDIO) { if (type == SRS_RTMP_TYPE_AUDIO) {
return context->enc.write_audio(time, data, size); if ((err = context->enc.write_audio(time, data, size)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret;
}
} else if (type == SRS_RTMP_TYPE_VIDEO) { } else if (type == SRS_RTMP_TYPE_VIDEO) {
return context->enc.write_video(time, data, size); if ((err = context->enc.write_video(time, data, size)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret;
}
} else { } else {
return context->enc.write_metadata(type, data, size); if ((err = context->enc.write_metadata(type, data, size)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret;
}
} }
return ret; return ret;
@ -1845,22 +1922,21 @@ extern "C"{
srs_amf0_t srs_amf0_parse(char* data, int size, int* nparsed) srs_amf0_t srs_amf0_parse(char* data, int size, int* nparsed)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
srs_amf0_t amf0 = NULL; srs_amf0_t amf0 = NULL;
SrsBuffer stream; SrsBuffer stream(data, size);
if ((ret = stream.initialize(data, size)) != ERROR_SUCCESS) {
return amf0;
}
SrsAmf0Any* any = NULL; SrsAmf0Any* any = NULL;
if ((ret = SrsAmf0Any::discovery(&stream, &any)) != ERROR_SUCCESS) { if ((err = SrsAmf0Any::discovery(&stream, &any)) != srs_success) {
srs_freep(err);
return amf0; return amf0;
} }
stream.skip(-1 * stream.pos()); stream.skip(-1 * stream.pos());
if ((ret = any->read(&stream)) != ERROR_SUCCESS) { if ((err = any->read(&stream)) != srs_success) {
srs_freep(err);
srs_freep(any); srs_freep(any);
return amf0; return amf0;
} }
@ -1929,15 +2005,15 @@ extern "C"{
int srs_amf0_serialize(srs_amf0_t amf0, char* data, int size) int srs_amf0_serialize(srs_amf0_t amf0, char* data, int size)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
SrsAmf0Any* any = (SrsAmf0Any*)amf0; SrsAmf0Any* any = (SrsAmf0Any*)amf0;
SrsBuffer stream; SrsBuffer stream(data, size);
if ((ret = stream.initialize(data, size)) != ERROR_SUCCESS) {
return ret;
}
if ((ret = any->write(&stream)) != ERROR_SUCCESS) { if ((err = any->write(&stream)) != srs_success) {
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }

152
trunk/src/main/srs_main_ingest_hls.cpp
View file

@ -156,18 +156,14 @@ private:
std::vector<SrsTsPiece*> pieces; std::vector<SrsTsPiece*> pieces;
int64_t next_connect_time; int64_t next_connect_time;
private: private:
SrsBuffer* stream;
SrsTsContext* context; SrsTsContext* context;
public: public:
SrsIngestHlsInput(SrsHttpUri* hls) { SrsIngestHlsInput(SrsHttpUri* hls) {
in_hls = hls; in_hls = hls;
next_connect_time = 0; next_connect_time = 0;
stream = new SrsBuffer();
context = new SrsTsContext(); context = new SrsTsContext();
} }
virtual ~SrsIngestHlsInput() { virtual ~SrsIngestHlsInput() {
srs_freep(stream);
srs_freep(context); srs_freep(context);
std::vector<SrsTsPiece*>::iterator it; std::vector<SrsTsPiece*>::iterator it;
@ -291,9 +287,8 @@ int SrsIngestHlsInput::parseTs(ISrsTsHandler* handler, char* body, int nb_body)
int nb_packet = (int)nb_body / SRS_TS_PACKET_SIZE; int nb_packet = (int)nb_body / SRS_TS_PACKET_SIZE;
for (int i = 0; i < nb_packet; i++) { for (int i = 0; i < nb_packet; i++) {
char* p = (char*)body + (i * SRS_TS_PACKET_SIZE); char* p = (char*)body + (i * SRS_TS_PACKET_SIZE);
if ((ret = stream->initialize(p, SRS_TS_PACKET_SIZE)) != ERROR_SUCCESS) { SrsBuffer* stream = new SrsBuffer(p, SRS_TS_PACKET_SIZE);
return ret; SrsAutoFree(SrsBuffer, stream);
}
// process each ts packet // process each ts packet
if ((err = context->decode(stream, handler)) != srs_success) { if ((err = context->decode(stream, handler)) != srs_success) {
@ -314,9 +309,8 @@ int SrsIngestHlsInput::parseAac(ISrsAacHandler* handler, char* body, int nb_body
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
if ((ret = stream->initialize(body, nb_body)) != ERROR_SUCCESS) { SrsBuffer* stream = new SrsBuffer(body, nb_body);
return ret; SrsAutoFree(SrsBuffer, stream);
}
// atleast 2bytes. // atleast 2bytes.
if (!stream->require(3)) { if (!stream->require(3)) {
@ -396,7 +390,10 @@ int SrsIngestHlsInput::parseM3u8(SrsHttpUri* url, double& td, double& duration)
SrsAutoFree(ISrsHttpMessage, msg); SrsAutoFree(ISrsHttpMessage, msg);
std::string body; std::string body;
if ((ret = msg->body_read_all(body)) != ERROR_SUCCESS) { if ((err = msg->body_read_all(body)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
srs_error("read m3u8 failed. ret=%d", ret); srs_error("read m3u8 failed. ret=%d", ret);
return ret; return ret;
} }
@ -465,7 +462,10 @@ int SrsIngestHlsInput::parseM3u8(SrsHttpUri* url, double& td, double& duration)
} }
srs_trace("parse sub m3u8, url=%s", m3u8_url.c_str()); srs_trace("parse sub m3u8, url=%s", m3u8_url.c_str());
if ((ret = url->initialize(m3u8_url)) != ERROR_SUCCESS) { if ((err = url->initialize(m3u8_url)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -600,7 +600,10 @@ int SrsIngestHlsInput::SrsTsPiece::fetch(string m3u8)
} }
SrsHttpUri uri; SrsHttpUri uri;
if ((ret = uri.initialize(ts_url)) != ERROR_SUCCESS) { if ((err = uri.initialize(ts_url)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -621,7 +624,10 @@ int SrsIngestHlsInput::SrsTsPiece::fetch(string m3u8)
srs_assert(msg); srs_assert(msg);
SrsAutoFree(ISrsHttpMessage, msg); SrsAutoFree(ISrsHttpMessage, msg);
if ((ret = msg->body_read_all(body)) != ERROR_SUCCESS) { if ((err = msg->body_read_all(body)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
srs_error("read ts failed. ret=%d", ret); srs_error("read ts failed. ret=%d", ret);
return ret; return ret;
} }
@ -792,21 +798,16 @@ srs_error_t SrsIngestHlsOutput::on_ts_message(SrsTsMessage* msg)
int SrsIngestHlsOutput::on_aac_frame(char* frame, int frame_size, double duration) int SrsIngestHlsOutput::on_aac_frame(char* frame, int frame_size, double duration)
{ {
int ret = ERROR_SUCCESS;
srs_trace("handle aac frames, size=%dB, duration=%.2f, dts=%" PRId64, frame_size, duration, raw_aac_dts); srs_trace("handle aac frames, size=%dB, duration=%.2f, dts=%" PRId64, frame_size, duration, raw_aac_dts);
SrsBuffer stream; SrsBuffer stream(frame, frame_size);
if ((ret = stream.initialize(frame, frame_size)) != ERROR_SUCCESS) {
return ret;
}
return do_on_aac_frame(&stream, duration); return do_on_aac_frame(&stream, duration);
} }
int SrsIngestHlsOutput::do_on_aac_frame(SrsBuffer* avs, double duration) int SrsIngestHlsOutput::do_on_aac_frame(SrsBuffer* avs, double duration)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
uint32_t duration_ms = (uint32_t)(duration * 1000); uint32_t duration_ms = (uint32_t)(duration * 1000);
@ -822,7 +823,10 @@ int SrsIngestHlsOutput::do_on_aac_frame(SrsBuffer* avs, double duration)
char* frame = NULL; char* frame = NULL;
int frame_size = 0; int frame_size = 0;
SrsRawAacStreamCodec codec; SrsRawAacStreamCodec codec;
if ((ret = aac->adts_demux(avs, &frame, &frame_size, codec)) != ERROR_SUCCESS) { if ((err = aac->adts_demux(avs, &frame, &frame_size, codec)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -836,7 +840,10 @@ int SrsIngestHlsOutput::do_on_aac_frame(SrsBuffer* avs, double duration)
// generate sh. // generate sh.
if (aac_specific_config.empty()) { if (aac_specific_config.empty()) {
std::string sh; std::string sh;
if ((ret = aac->mux_sequence_header(&codec, sh)) != ERROR_SUCCESS) { if ((err = aac->mux_sequence_header(&codec, sh)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
aac_specific_config = sh; aac_specific_config = sh;
@ -905,11 +912,7 @@ int SrsIngestHlsOutput::parse_message_queue()
queue.erase(it); queue.erase(it);
// parse the stream. // parse the stream.
SrsBuffer avs; SrsBuffer avs(msg->payload->bytes(), msg->payload->length());
if ((ret = avs.initialize(msg->payload->bytes(), msg->payload->length())) != ERROR_SUCCESS) {
srs_error("mpegts: initialize av stream failed. ret=%d", ret);
return ret;
}
// publish audio or video. // publish audio or video.
if (msg->channel->stream == SrsTsStreamVideoH264) { if (msg->channel->stream == SrsTsStreamVideoH264) {
@ -939,11 +942,7 @@ int SrsIngestHlsOutput::flush_message_queue()
queue.erase(it); queue.erase(it);
// parse the stream. // parse the stream.
SrsBuffer avs; SrsBuffer avs(msg->payload->bytes(), msg->payload->length());
if ((ret = avs.initialize(msg->payload->bytes(), msg->payload->length())) != ERROR_SUCCESS) {
srs_error("mpegts: initialize av stream failed. ret=%d", ret);
return ret;
}
// publish audio or video. // publish audio or video.
if (msg->channel->stream == SrsTsStreamVideoH264) { if (msg->channel->stream == SrsTsStreamVideoH264) {
@ -964,6 +963,7 @@ int SrsIngestHlsOutput::flush_message_queue()
int SrsIngestHlsOutput::on_ts_video(SrsTsMessage* msg, SrsBuffer* avs) int SrsIngestHlsOutput::on_ts_video(SrsTsMessage* msg, SrsBuffer* avs)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// ts tbn to flv tbn. // ts tbn to flv tbn.
uint32_t dts = (uint32_t)(msg->dts / 90); uint32_t dts = (uint32_t)(msg->dts / 90);
@ -976,7 +976,10 @@ int SrsIngestHlsOutput::on_ts_video(SrsTsMessage* msg, SrsBuffer* avs)
while (!avs->empty()) { while (!avs->empty()) {
char* frame = NULL; char* frame = NULL;
int frame_size = 0; int frame_size = 0;
if ((ret = avc->annexb_demux(avs, &frame, &frame_size)) != ERROR_SUCCESS) { if ((err = avc->annexb_demux(avs, &frame, &frame_size)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -998,7 +1001,10 @@ int SrsIngestHlsOutput::on_ts_video(SrsTsMessage* msg, SrsBuffer* avs)
// for sps // for sps
if (avc->is_sps(frame, frame_size)) { if (avc->is_sps(frame, frame_size)) {
std::string sps; std::string sps;
if ((ret = avc->sps_demux(frame, frame_size, sps)) != ERROR_SUCCESS) { if ((err = avc->sps_demux(frame, frame_size, sps)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1013,7 +1019,10 @@ int SrsIngestHlsOutput::on_ts_video(SrsTsMessage* msg, SrsBuffer* avs)
// for pps // for pps
if (avc->is_pps(frame, frame_size)) { if (avc->is_pps(frame, frame_size)) {
std::string pps; std::string pps;
if ((ret = avc->pps_demux(frame, frame_size, pps)) != ERROR_SUCCESS) { if ((err = avc->pps_demux(frame, frame_size, pps)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1027,7 +1036,10 @@ int SrsIngestHlsOutput::on_ts_video(SrsTsMessage* msg, SrsBuffer* avs)
// ibp frame. // ibp frame.
std::string ibp; std::string ibp;
if ((ret = avc->mux_ipb_frame(frame, frame_size, ibp)) != ERROR_SUCCESS) { if ((err = avc->mux_ipb_frame(frame, frame_size, ibp)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
ibps.append(ibp); ibps.append(ibp);
@ -1051,6 +1063,7 @@ int SrsIngestHlsOutput::on_ts_video(SrsTsMessage* msg, SrsBuffer* avs)
int SrsIngestHlsOutput::write_h264_sps_pps(uint32_t dts, uint32_t pts) int SrsIngestHlsOutput::write_h264_sps_pps(uint32_t dts, uint32_t pts)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// when sps or pps changed, update the sequence header, // when sps or pps changed, update the sequence header,
// for the pps maybe not changed while sps changed. // for the pps maybe not changed while sps changed.
@ -1066,7 +1079,10 @@ int SrsIngestHlsOutput::write_h264_sps_pps(uint32_t dts, uint32_t pts)
// h264 raw to h264 packet. // h264 raw to h264 packet.
std::string sh; std::string sh;
if ((ret = avc->mux_sequence_header(h264_sps, h264_pps, dts, pts, sh)) != ERROR_SUCCESS) { if ((err = avc->mux_sequence_header(h264_sps, h264_pps, dts, pts, sh)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1075,7 +1091,10 @@ int SrsIngestHlsOutput::write_h264_sps_pps(uint32_t dts, uint32_t pts)
int8_t avc_packet_type = SrsVideoAvcFrameTraitSequenceHeader; int8_t avc_packet_type = SrsVideoAvcFrameTraitSequenceHeader;
char* flv = NULL; char* flv = NULL;
int nb_flv = 0; int nb_flv = 0;
if ((ret = avc->mux_avc2flv(sh, frame_type, avc_packet_type, dts, pts, &flv, &nb_flv)) != ERROR_SUCCESS) { if ((err = avc->mux_avc2flv(sh, frame_type, avc_packet_type, dts, pts, &flv, &nb_flv)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1097,6 +1116,7 @@ int SrsIngestHlsOutput::write_h264_sps_pps(uint32_t dts, uint32_t pts)
int SrsIngestHlsOutput::write_h264_ipb_frame(string ibps, SrsVideoAvcFrameType frame_type, uint32_t dts, uint32_t pts) int SrsIngestHlsOutput::write_h264_ipb_frame(string ibps, SrsVideoAvcFrameType frame_type, uint32_t dts, uint32_t pts)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// when sps or pps not sent, ignore the packet. // when sps or pps not sent, ignore the packet.
// @see https://github.com/ossrs/srs/issues/203 // @see https://github.com/ossrs/srs/issues/203
@ -1107,7 +1127,10 @@ int SrsIngestHlsOutput::write_h264_ipb_frame(string ibps, SrsVideoAvcFrameType f
int8_t avc_packet_type = SrsVideoAvcFrameTraitNALU; int8_t avc_packet_type = SrsVideoAvcFrameTraitNALU;
char* flv = NULL; char* flv = NULL;
int nb_flv = 0; int nb_flv = 0;
if ((ret = avc->mux_avc2flv(ibps, frame_type, avc_packet_type, dts, pts, &flv, &nb_flv)) != ERROR_SUCCESS) { if ((err = avc->mux_avc2flv(ibps, frame_type, avc_packet_type, dts, pts, &flv, &nb_flv)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1119,6 +1142,7 @@ int SrsIngestHlsOutput::write_h264_ipb_frame(string ibps, SrsVideoAvcFrameType f
int SrsIngestHlsOutput::on_ts_audio(SrsTsMessage* msg, SrsBuffer* avs) int SrsIngestHlsOutput::on_ts_audio(SrsTsMessage* msg, SrsBuffer* avs)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// ts tbn to flv tbn. // ts tbn to flv tbn.
uint32_t dts = (uint32_t)(msg->dts / 90); uint32_t dts = (uint32_t)(msg->dts / 90);
@ -1136,7 +1160,10 @@ int SrsIngestHlsOutput::on_ts_audio(SrsTsMessage* msg, SrsBuffer* avs)
char* frame = NULL; char* frame = NULL;
int frame_size = 0; int frame_size = 0;
SrsRawAacStreamCodec codec; SrsRawAacStreamCodec codec;
if ((ret = aac->adts_demux(avs, &frame, &frame_size, codec)) != ERROR_SUCCESS) { if ((err = aac->adts_demux(avs, &frame, &frame_size, codec)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1150,7 +1177,10 @@ int SrsIngestHlsOutput::on_ts_audio(SrsTsMessage* msg, SrsBuffer* avs)
// generate sh. // generate sh.
if (aac_specific_config.empty()) { if (aac_specific_config.empty()) {
std::string sh; std::string sh;
if ((ret = aac->mux_sequence_header(&codec, sh)) != ERROR_SUCCESS) { if ((err = aac->mux_sequence_header(&codec, sh)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
aac_specific_config = sh; aac_specific_config = sh;
@ -1179,10 +1209,14 @@ int SrsIngestHlsOutput::on_ts_audio(SrsTsMessage* msg, SrsBuffer* avs)
int SrsIngestHlsOutput::write_audio_raw_frame(char* frame, int frame_size, SrsRawAacStreamCodec* codec, uint32_t dts) int SrsIngestHlsOutput::write_audio_raw_frame(char* frame, int frame_size, SrsRawAacStreamCodec* codec, uint32_t dts)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
char* data = NULL; char* data = NULL;
int size = 0; int size = 0;
if ((ret = aac->mux_aac2flv(frame, frame_size, codec, dts, &data, &size)) != ERROR_SUCCESS) { if ((err = aac->mux_aac2flv(frame, frame_size, codec, dts, &data, &size)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -1192,6 +1226,7 @@ int SrsIngestHlsOutput::write_audio_raw_frame(char* frame, int frame_size, SrsRa
int SrsIngestHlsOutput::rtmp_write_packet(char type, uint32_t timestamp, char* data, int size) int SrsIngestHlsOutput::rtmp_write_packet(char type, uint32_t timestamp, char* data, int size)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if ((ret = connect()) != ERROR_SUCCESS) { if ((ret = connect()) != ERROR_SUCCESS) {
return ret; return ret;
@ -1199,7 +1234,10 @@ int SrsIngestHlsOutput::rtmp_write_packet(char type, uint32_t timestamp, char* d
SrsSharedPtrMessage* msg = NULL; SrsSharedPtrMessage* msg = NULL;
if ((ret = srs_rtmp_create_msg(type, timestamp, data, size, sdk->sid(), &msg)) != ERROR_SUCCESS) { if ((err = srs_rtmp_create_msg(type, timestamp, data, size, sdk->sid(), &msg)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
srs_error("mpegts: create shared ptr msg failed. ret=%d", ret); srs_error("mpegts: create shared ptr msg failed. ret=%d", ret);
return ret; return ret;
} }
@ -1208,7 +1246,10 @@ int SrsIngestHlsOutput::rtmp_write_packet(char type, uint32_t timestamp, char* d
srs_info("RTMP type=%d, dts=%d, size=%d", type, timestamp, size); srs_info("RTMP type=%d, dts=%d, size=%d", type, timestamp, size);
// send out encoded msg. // send out encoded msg.
if ((ret = sdk->send_and_free_message(msg)) != ERROR_SUCCESS) { if ((err = sdk->send_and_free_message(msg)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
close(); close();
srs_error("send RTMP type=%d, dts=%d, size=%d failed. ret=%d", type, timestamp, size, ret); srs_error("send RTMP type=%d, dts=%d, size=%d failed. ret=%d", type, timestamp, size, ret);
return ret; return ret;
@ -1220,6 +1261,7 @@ int SrsIngestHlsOutput::rtmp_write_packet(char type, uint32_t timestamp, char* d
int SrsIngestHlsOutput::connect() int SrsIngestHlsOutput::connect()
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// Ignore when connected. // Ignore when connected.
if (sdk) { if (sdk) {
@ -1234,14 +1276,20 @@ int SrsIngestHlsOutput::connect()
int64_t sto = SRS_CONSTS_RTMP_PULSE_TMMS; int64_t sto = SRS_CONSTS_RTMP_PULSE_TMMS;
sdk = new SrsBasicRtmpClient(url, cto, sto); sdk = new SrsBasicRtmpClient(url, cto, sto);
if ((ret = sdk->connect()) != ERROR_SUCCESS) { if ((err = sdk->connect()) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
close(); close();
srs_error("mpegts: connect %s failed, cto=%" PRId64 ", sto=%" PRId64 ". ret=%d", url.c_str(), cto, sto, ret); srs_error("mpegts: connect %s failed, cto=%" PRId64 ", sto=%" PRId64 ". ret=%d", url.c_str(), cto, sto, ret);
return ret; return ret;
} }
// publish. // publish.
if ((ret = sdk->publish()) != ERROR_SUCCESS) { if ((err = sdk->publish()) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
close(); close();
srs_error("mpegts: publish %s failed. ret=%d", url.c_str(), ret); srs_error("mpegts: publish %s failed. ret=%d", url.c_str(), ret);
return ret; return ret;
@ -1301,7 +1349,6 @@ public:
srs_error_t proxy_hls2rtmp(string hls, string rtmp) srs_error_t proxy_hls2rtmp(string hls, string rtmp)
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
// init st. // init st.
@ -1310,15 +1357,16 @@ srs_error_t proxy_hls2rtmp(string hls, string rtmp)
} }
SrsHttpUri hls_uri, rtmp_uri; SrsHttpUri hls_uri, rtmp_uri;
if ((ret = hls_uri.initialize(hls)) != ERROR_SUCCESS) { if ((err = hls_uri.initialize(hls)) != srs_success) {
return srs_error_new(ret, "hls parse uri=%s", hls.c_str()); return srs_error_wrap(err, "hls parse uri=%s", hls.c_str());
} }
if ((ret = rtmp_uri.initialize(rtmp)) != ERROR_SUCCESS) { if ((err = rtmp_uri.initialize(rtmp)) != srs_success) {
return srs_error_new(ret, "rtmp parse uri=%s", rtmp.c_str()); return srs_error_wrap(err, "rtmp parse uri=%s", rtmp.c_str());
} }
SrsIngestHlsContext context(&hls_uri, &rtmp_uri); SrsIngestHlsContext context(&hls_uri, &rtmp_uri);
for (;;) { for (;;) {
int ret = ERROR_SUCCESS;
if ((ret = context.proxy()) != ERROR_SUCCESS) { if ((ret = context.proxy()) != ERROR_SUCCESS) {
return srs_error_new(ret, "proxy hls to rtmp"); return srs_error_new(ret, "proxy hls to rtmp");
} }

26
trunk/src/main/srs_main_mp4_parser.cpp
View file

@ -43,16 +43,23 @@ ISrsThreadContext* _srs_context = new SrsThreadContext();
int parse(std::string mp4_file, bool verbose) int parse(std::string mp4_file, bool verbose)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
SrsFileReader fr; SrsFileReader fr;
if ((ret = fr.open(mp4_file)) != ERROR_SUCCESS) { if ((err = fr.open(mp4_file)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
srs_error("Open MP4 file failed, ret=%d", ret); srs_error("Open MP4 file failed, ret=%d", ret);
return ret; return ret;
} }
srs_trace("MP4 file open success"); srs_trace("MP4 file open success");
SrsMp4BoxReader br; SrsMp4BoxReader br;
if ((ret = br.initialize(&fr)) != ERROR_SUCCESS) { if ((err = br.initialize(&fr)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
srs_error("Open MP4 box reader failed, ret=%d", ret); srs_error("Open MP4 box reader failed, ret=%d", ret);
return ret; return ret;
} }
@ -66,7 +73,10 @@ int parse(std::string mp4_file, bool verbose)
SrsMp4Box* box = NULL; SrsMp4Box* box = NULL;
SrsAutoFree(SrsMp4Box, box); SrsAutoFree(SrsMp4Box, box);
if ((ret = br.read(stream, &box)) != ERROR_SUCCESS) { if ((err = br.read(stream, &box)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
if (ret != ERROR_SYSTEM_FILE_EOF) { if (ret != ERROR_SYSTEM_FILE_EOF) {
srs_error("Read MP4 box failed, ret=%d", ret); srs_error("Read MP4 box failed, ret=%d", ret);
} else { } else {
@ -78,12 +88,18 @@ int parse(std::string mp4_file, bool verbose)
SrsBuffer* buffer = new SrsBuffer(stream->bytes(), stream->length()); SrsBuffer* buffer = new SrsBuffer(stream->bytes(), stream->length());
SrsAutoFree(SrsBuffer, buffer); SrsAutoFree(SrsBuffer, buffer);
if ((ret = box->decode(buffer)) != ERROR_SUCCESS) { if ((err = box->decode(buffer)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
srs_error("Decode the box failed, ret=%d", ret); srs_error("Decode the box failed, ret=%d", ret);
return ret; return ret;
} }
if ((ret = br.skip(box, stream)) != ERROR_SUCCESS) { if ((err = br.skip(box, stream)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
srs_error("Skip MP4 box failed, ret=%d", ret); srs_error("Skip MP4 box failed, ret=%d", ret);
return ret; return ret;
} }

113
trunk/src/utest/srs_utest_amf0.cpp
View file

@ -80,10 +80,9 @@ VOID TEST(ProtocolAMF0Test, ScenarioMain)
bytes = new char[nb_bytes]; bytes = new char[nb_bytes];
// use SrsBuffer to write props/info to binary buf. // use SrsBuffer to write props/info to binary buf.
SrsBuffer s; SrsBuffer s(bytes, nb_bytes);
EXPECT_EQ(ERROR_SUCCESS, s.initialize(bytes, nb_bytes)); EXPECT_EQ(srs_success, props->write(&s));
EXPECT_EQ(ERROR_SUCCESS, props->write(&s)); EXPECT_EQ(srs_success, info->write(&s));
EXPECT_EQ(ERROR_SUCCESS, info->write(&s));
EXPECT_TRUE(s.empty()); EXPECT_TRUE(s.empty());
// now, user can use the buf // now, user can use the buf
@ -98,20 +97,19 @@ VOID TEST(ProtocolAMF0Test, ScenarioMain)
ASSERT_TRUE(NULL != bytes); ASSERT_TRUE(NULL != bytes);
// use SrsBuffer to assist amf0 object to read from bytes. // use SrsBuffer to assist amf0 object to read from bytes.
SrsBuffer s; SrsBuffer s(bytes, nb_bytes);
EXPECT_EQ(ERROR_SUCCESS, s.initialize(bytes, nb_bytes));
// decoding // decoding
// if user know the schema, for instance, it's an amf0 object, // if user know the schema, for instance, it's an amf0 object,
// user can use specified object to decoding. // user can use specified object to decoding.
SrsAmf0Object* props = SrsAmf0Any::object(); SrsAmf0Object* props = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, props); SrsAutoFree(SrsAmf0Object, props);
EXPECT_EQ(ERROR_SUCCESS, props->read(&s)); EXPECT_EQ(srs_success, props->read(&s));
// user can use specified object to decoding. // user can use specified object to decoding.
SrsAmf0Object* info = SrsAmf0Any::object(); SrsAmf0Object* info = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, info); SrsAutoFree(SrsAmf0Object, info);
EXPECT_EQ(ERROR_SUCCESS, info->read(&s)); EXPECT_EQ(srs_success, info->read(&s));
// use the decoded data. // use the decoded data.
SrsAmf0Any* prop = NULL; SrsAmf0Any* prop = NULL;
@ -149,12 +147,11 @@ VOID TEST(ProtocolAMF0Test, ScenarioMain)
ASSERT_TRUE(NULL != bytes); ASSERT_TRUE(NULL != bytes);
// use SrsBuffer to assist amf0 object to read from bytes. // use SrsBuffer to assist amf0 object to read from bytes.
SrsBuffer s; SrsBuffer s(bytes, nb_bytes);
EXPECT_EQ(ERROR_SUCCESS, s.initialize(bytes, nb_bytes));
// decoding a amf0 any, for user donot know // decoding a amf0 any, for user donot know
SrsAmf0Any* any = NULL; SrsAmf0Any* any = NULL;
EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &any)); EXPECT_EQ(srs_success, srs_amf0_read_any(&s, &any));
SrsAutoFree(SrsAmf0Any, any); SrsAutoFree(SrsAmf0Any, any);
// for amf0 object // for amf0 object
@ -526,12 +523,11 @@ VOID TEST(ProtocolAMF0Test, ApiAnyElem)
*/ */
VOID TEST(ProtocolAMF0Test, ApiAnyIO) VOID TEST(ProtocolAMF0Test, ApiAnyIO)
{ {
SrsBuffer s;
SrsAmf0Any* o = NULL; SrsAmf0Any* o = NULL;
char buf[1024]; char buf[1024];
memset(buf, 0, sizeof(buf)); memset(buf, 0, sizeof(buf));
EXPECT_EQ(ERROR_SUCCESS, s.initialize(buf, sizeof(buf))); SrsBuffer s(buf, sizeof(buf));
// object eof // object eof
if (true) { if (true) {
@ -541,13 +537,13 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::object_eof(); o = SrsAmf0Any::object_eof();
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(srs_success, o->read(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
EXPECT_EQ(3, s.pos()); EXPECT_EQ(3, s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
(s.data() + s.pos())[0] = 0x01; (s.data() + s.pos())[0] = 0x01;
EXPECT_NE(ERROR_SUCCESS, o->read(&s)); EXPECT_NE(srs_success, o->read(&s));
} }
if (true) { if (true) {
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
@ -555,7 +551,7 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::object_eof(); o = SrsAmf0Any::object_eof();
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
EXPECT_EQ(3, s.pos()); EXPECT_EQ(3, s.pos());
@ -570,7 +566,7 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::str("winlin"); o = SrsAmf0Any::str("winlin");
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
@ -581,7 +577,7 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
(s.data() + s.pos())[3] = 'x'; (s.data() + s.pos())[3] = 'x';
EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(srs_success, o->read(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
EXPECT_STREQ("xinlin", o->to_str().c_str()); EXPECT_STREQ("xinlin", o->to_str().c_str());
} }
@ -593,14 +589,14 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::number(10); o = SrsAmf0Any::number(10);
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(0, s.read_1bytes()); EXPECT_EQ(0, s.read_1bytes());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(srs_success, o->read(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
EXPECT_DOUBLE_EQ(10, o->to_number()); EXPECT_DOUBLE_EQ(10, o->to_number());
} }
@ -612,14 +608,14 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::boolean(true); o = SrsAmf0Any::boolean(true);
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(1, s.read_1bytes()); EXPECT_EQ(1, s.read_1bytes());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(srs_success, o->read(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
EXPECT_TRUE(o->to_boolean()); EXPECT_TRUE(o->to_boolean());
} }
@ -629,14 +625,14 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::boolean(false); o = SrsAmf0Any::boolean(false);
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(1, s.read_1bytes()); EXPECT_EQ(1, s.read_1bytes());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(srs_success, o->read(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
EXPECT_FALSE(o->to_boolean()); EXPECT_FALSE(o->to_boolean());
} }
@ -648,14 +644,14 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::null(); o = SrsAmf0Any::null();
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(5, s.read_1bytes()); EXPECT_EQ(5, s.read_1bytes());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(srs_success, o->read(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
EXPECT_TRUE(o->is_null()); EXPECT_TRUE(o->is_null());
} }
@ -667,14 +663,14 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::undefined(); o = SrsAmf0Any::undefined();
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(6, s.read_1bytes()); EXPECT_EQ(6, s.read_1bytes());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(srs_success, o->read(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
EXPECT_TRUE(o->is_undefined()); EXPECT_TRUE(o->is_undefined());
} }
@ -686,13 +682,13 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::str("winlin"); o = SrsAmf0Any::str("winlin");
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
SrsAmf0Any* po = NULL; SrsAmf0Any* po = NULL;
EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); EXPECT_EQ(srs_success, srs_amf0_read_any(&s, &po));
ASSERT_TRUE(NULL != po); ASSERT_TRUE(NULL != po);
SrsAutoFree(SrsAmf0Any, po); SrsAutoFree(SrsAmf0Any, po);
ASSERT_TRUE(po->is_string()); ASSERT_TRUE(po->is_string());
@ -706,13 +702,13 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::number(10); o = SrsAmf0Any::number(10);
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
SrsAmf0Any* po = NULL; SrsAmf0Any* po = NULL;
EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); EXPECT_EQ(srs_success, srs_amf0_read_any(&s, &po));
ASSERT_TRUE(NULL != po); ASSERT_TRUE(NULL != po);
SrsAutoFree(SrsAmf0Any, po); SrsAutoFree(SrsAmf0Any, po);
ASSERT_TRUE(po->is_number()); ASSERT_TRUE(po->is_number());
@ -726,13 +722,13 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::boolean(true); o = SrsAmf0Any::boolean(true);
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
SrsAmf0Any* po = NULL; SrsAmf0Any* po = NULL;
EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); EXPECT_EQ(srs_success, srs_amf0_read_any(&s, &po));
ASSERT_TRUE(NULL != po); ASSERT_TRUE(NULL != po);
SrsAutoFree(SrsAmf0Any, po); SrsAutoFree(SrsAmf0Any, po);
ASSERT_TRUE(po->is_boolean()); ASSERT_TRUE(po->is_boolean());
@ -746,13 +742,13 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::null(); o = SrsAmf0Any::null();
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
SrsAmf0Any* po = NULL; SrsAmf0Any* po = NULL;
EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); EXPECT_EQ(srs_success, srs_amf0_read_any(&s, &po));
ASSERT_TRUE(NULL != po); ASSERT_TRUE(NULL != po);
SrsAutoFree(SrsAmf0Any, po); SrsAutoFree(SrsAmf0Any, po);
ASSERT_TRUE(po->is_null()); ASSERT_TRUE(po->is_null());
@ -765,13 +761,13 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
o = SrsAmf0Any::undefined(); o = SrsAmf0Any::undefined();
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(o->total_size(), s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
SrsAmf0Any* po = NULL; SrsAmf0Any* po = NULL;
EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); EXPECT_EQ(srs_success, srs_amf0_read_any(&s, &po));
ASSERT_TRUE(NULL != po); ASSERT_TRUE(NULL != po);
SrsAutoFree(SrsAmf0Any, po); SrsAutoFree(SrsAmf0Any, po);
ASSERT_TRUE(po->is_undefined()); ASSERT_TRUE(po->is_undefined());
@ -782,52 +778,52 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
o = SrsAmf0Any::str("winlin"); o = SrsAmf0Any::str("winlin");
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
srs_freep(o); srs_freep(o);
o = SrsAmf0Any::number(10); o = SrsAmf0Any::number(10);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
srs_freep(o); srs_freep(o);
o = SrsAmf0Any::boolean(true); o = SrsAmf0Any::boolean(true);
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
srs_freep(o); srs_freep(o);
o = SrsAmf0Any::null(); o = SrsAmf0Any::null();
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
srs_freep(o); srs_freep(o);
o = SrsAmf0Any::undefined(); o = SrsAmf0Any::undefined();
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
srs_freep(o); srs_freep(o);
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
SrsAmf0Any* po = NULL; SrsAmf0Any* po = NULL;
EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); EXPECT_EQ(srs_success, srs_amf0_read_any(&s, &po));
ASSERT_TRUE(NULL != po); ASSERT_TRUE(NULL != po);
ASSERT_TRUE(po->is_string()); ASSERT_TRUE(po->is_string());
EXPECT_STREQ("winlin", po->to_str().c_str()); EXPECT_STREQ("winlin", po->to_str().c_str());
srs_freep(po); srs_freep(po);
EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); EXPECT_EQ(srs_success, srs_amf0_read_any(&s, &po));
ASSERT_TRUE(NULL != po); ASSERT_TRUE(NULL != po);
ASSERT_TRUE(po->is_number()); ASSERT_TRUE(po->is_number());
EXPECT_DOUBLE_EQ(10, po->to_number()); EXPECT_DOUBLE_EQ(10, po->to_number());
srs_freep(po); srs_freep(po);
EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); EXPECT_EQ(srs_success, srs_amf0_read_any(&s, &po));
ASSERT_TRUE(NULL != po); ASSERT_TRUE(NULL != po);
ASSERT_TRUE(po->is_boolean()); ASSERT_TRUE(po->is_boolean());
EXPECT_TRUE(po->to_boolean()); EXPECT_TRUE(po->to_boolean());
srs_freep(po); srs_freep(po);
EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); EXPECT_EQ(srs_success, srs_amf0_read_any(&s, &po));
ASSERT_TRUE(NULL != po); ASSERT_TRUE(NULL != po);
ASSERT_TRUE(po->is_null()); ASSERT_TRUE(po->is_null());
srs_freep(po); srs_freep(po);
EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); EXPECT_EQ(srs_success, srs_amf0_read_any(&s, &po));
ASSERT_TRUE(NULL != po); ASSERT_TRUE(NULL != po);
ASSERT_TRUE(po->is_undefined()); ASSERT_TRUE(po->is_undefined());
srs_freep(po); srs_freep(po);
@ -837,20 +833,19 @@ VOID TEST(ProtocolAMF0Test, ApiAnyIO)
/** /**
* to get the type identity * to get the type identity
*/ */
VOID TEST(ProtocolAMF0Test, ApiAnyTypeAssert) VOID TEST(ProtocolAMF0Test, ApiAnyTypeAssert)
{ {
SrsBuffer s;
SrsAmf0Any* o = NULL; SrsAmf0Any* o = NULL;
char buf[1024]; char buf[1024];
memset(buf, 0, sizeof(buf)); memset(buf, 0, sizeof(buf));
EXPECT_EQ(ERROR_SUCCESS, s.initialize(buf, sizeof(buf))); SrsBuffer s(buf, sizeof(buf));
// read any // read any
if (true) { if (true) {
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
(s.data() + s.pos())[0] = 0x12; (s.data() + s.pos())[0] = 0x12;
EXPECT_NE(ERROR_SUCCESS, srs_amf0_read_any(&s, &o)); EXPECT_NE(srs_success, srs_amf0_read_any(&s, &o));
EXPECT_TRUE(NULL == o); EXPECT_TRUE(NULL == o);
srs_freep(o); srs_freep(o);
} }
@ -902,7 +897,7 @@ VOID TEST(ProtocolAMF0Test, ApiAnyTypeAssert)
o = SrsAmf0Any::object(); o = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(1+3, s.pos()); EXPECT_EQ(1+3, s.pos());
} }
@ -911,7 +906,7 @@ VOID TEST(ProtocolAMF0Test, ApiAnyTypeAssert)
o = SrsAmf0Any::ecma_array(); o = SrsAmf0Any::ecma_array();
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(1+4+3, s.pos()); EXPECT_EQ(1+4+3, s.pos());
} }
@ -920,7 +915,7 @@ VOID TEST(ProtocolAMF0Test, ApiAnyTypeAssert)
o = SrsAmf0Any::strict_array(); o = SrsAmf0Any::strict_array();
SrsAutoFree(SrsAmf0Any, o); SrsAutoFree(SrsAmf0Any, o);
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(1+4, s.pos()); EXPECT_EQ(1+4, s.pos());
} }
} }
@ -1092,11 +1087,9 @@ VOID TEST(ProtocolAMF0Test, ApiEcmaArrayProps)
*/ */
VOID TEST(ProtocolAMF0Test, ApiStrictArray) VOID TEST(ProtocolAMF0Test, ApiStrictArray)
{ {
SrsBuffer s;
char buf[1024]; char buf[1024];
memset(buf, 0, sizeof(buf)); memset(buf, 0, sizeof(buf));
EXPECT_EQ(ERROR_SUCCESS, s.initialize(buf, sizeof(buf))); SrsBuffer s(buf, sizeof(buf));
SrsAmf0StrictArray* o = NULL; SrsAmf0StrictArray* o = NULL;
@ -1138,7 +1131,7 @@ VOID TEST(ProtocolAMF0Test, ApiStrictArray)
SrsAutoFree(SrsAmf0StrictArray, o); SrsAutoFree(SrsAmf0StrictArray, o);
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(5, s.pos()); EXPECT_EQ(5, s.pos());
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
@ -1153,7 +1146,7 @@ VOID TEST(ProtocolAMF0Test, ApiStrictArray)
o->append(SrsAmf0Any::number(0)); o->append(SrsAmf0Any::number(0));
s.skip(-1 * s.pos()); s.skip(-1 * s.pos());
EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(srs_success, o->write(&s));
EXPECT_EQ(5 + SrsAmf0Size::number(), s.pos()); EXPECT_EQ(5 + SrsAmf0Size::number(), s.pos());
} }
} }

174
trunk/src/utest/srs_utest_kernel.cpp
View file

@ -44,13 +44,11 @@ MockSrsFileWriter::~MockSrsFileWriter()
srs_freep(data); srs_freep(data);
} }
int MockSrsFileWriter::open(string /*file*/) srs_error_t MockSrsFileWriter::open(string /*file*/)
{ {
int ret = ERROR_SUCCESS;
offset = 0; offset = 0;
return ret; return srs_success;
} }
void MockSrsFileWriter::close() void MockSrsFileWriter::close()
@ -68,10 +66,8 @@ int64_t MockSrsFileWriter::tellg()
return offset; return offset;
} }
int MockSrsFileWriter::write(void* buf, size_t count, ssize_t* pnwrite) srs_error_t MockSrsFileWriter::write(void* buf, size_t count, ssize_t* pnwrite)
{ {
int ret = ERROR_SUCCESS;
int size = srs_min(MAX_MOCK_DATA_SIZE - offset, (int)count); int size = srs_min(MAX_MOCK_DATA_SIZE - offset, (int)count);
memcpy(data + offset, buf, size); memcpy(data + offset, buf, size);
@ -82,7 +78,7 @@ int MockSrsFileWriter::write(void* buf, size_t count, ssize_t* pnwrite)
offset += size; offset += size;
return ret; return srs_success;
} }
void MockSrsFileWriter::mock_reset_offset() void MockSrsFileWriter::mock_reset_offset()
@ -102,13 +98,11 @@ MockSrsFileReader::~MockSrsFileReader()
srs_freep(data); srs_freep(data);
} }
int MockSrsFileReader::open(string /*file*/) srs_error_t MockSrsFileReader::open(string /*file*/)
{ {
int ret = ERROR_SUCCESS;
offset = 0; offset = 0;
return ret; return srs_success;
} }
void MockSrsFileReader::close() void MockSrsFileReader::close()
@ -142,14 +136,12 @@ int64_t MockSrsFileReader::filesize()
return size; return size;
} }
int MockSrsFileReader::read(void* buf, size_t count, ssize_t* pnread) srs_error_t MockSrsFileReader::read(void* buf, size_t count, ssize_t* pnread)
{ {
int ret = ERROR_SUCCESS;
int s = srs_min(size - offset, (int)count); int s = srs_min(size - offset, (int)count);
if (s <= 0) { if (s <= 0) {
return ret; return srs_success;
} }
memcpy(buf, data + offset, s); memcpy(buf, data + offset, s);
@ -160,13 +152,13 @@ int MockSrsFileReader::read(void* buf, size_t count, ssize_t* pnread)
offset += s; offset += s;
return ret; return srs_success;
} }
int MockSrsFileReader::lseek(off_t _offset, int /*whence*/, off_t* /*seeked*/) srs_error_t MockSrsFileReader::lseek(off_t _offset, int /*whence*/, off_t* /*seeked*/)
{ {
offset = (int)_offset; offset = (int)_offset;
return ERROR_SUCCESS; return srs_success;
} }
void MockSrsFileReader::mock_append_data(const char* _data, int _size) void MockSrsFileReader::mock_append_data(const char* _data, int _size)
@ -192,7 +184,7 @@ MockBufferReader::~MockBufferReader()
{ {
} }
int MockBufferReader::read(void* buf, size_t size, ssize_t* nread) srs_error_t MockBufferReader::read(void* buf, size_t size, ssize_t* nread)
{ {
int len = srs_min(str.length(), size); int len = srs_min(str.length(), size);
@ -202,7 +194,7 @@ int MockBufferReader::read(void* buf, size_t size, ssize_t* nread)
*nread = len; *nread = len;
} }
return ERROR_SUCCESS; return srs_success;
} }
#ifdef ENABLE_UTEST_KERNEL #ifdef ENABLE_UTEST_KERNEL
@ -965,56 +957,13 @@ VOID TEST(KernelFlvTest, FlvVSDecoderSeek)
EXPECT_TRUE(5 == fs.offset); EXPECT_TRUE(5 == fs.offset);
} }
/**
* test the stream utility, bytes from/to basic types.
*/
VOID TEST(KernelStreamTest, StreamInitialize)
{
SrsBuffer s;
char data[1024];
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
EXPECT_TRUE(ERROR_SUCCESS != s.initialize(NULL, 1024));
EXPECT_TRUE(ERROR_SUCCESS != s.initialize(data, 0));
EXPECT_TRUE(ERROR_SUCCESS != s.initialize(data, -1));
}
/**
* test the stream utility, access data
*/
VOID TEST(KernelStreamTest, StreamData)
{
SrsBuffer s;
char data[1024];
EXPECT_TRUE(s.data() == NULL);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
EXPECT_TRUE(s.data() == data);
}
/**
* test the stream utility, access size
*/
VOID TEST(KernelStreamTest, StreamSize)
{
SrsBuffer s;
char data[1024];
EXPECT_TRUE(s.size() == 0);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
EXPECT_TRUE(s.size() == 1024);
}
/** /**
* test the stream utility, access pos * test the stream utility, access pos
*/ */
VOID TEST(KernelStreamTest, StreamPos) VOID TEST(KernelStreamTest, StreamPos)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(s.pos() == 0);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
EXPECT_TRUE(s.pos() == 0); EXPECT_TRUE(s.pos() == 0);
s.read_bytes(data, 1024); s.read_bytes(data, 1024);
@ -1026,11 +975,8 @@ VOID TEST(KernelStreamTest, StreamPos)
*/ */
VOID TEST(KernelStreamTest, StreamEmpty) VOID TEST(KernelStreamTest, StreamEmpty)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(s.empty());
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
EXPECT_FALSE(s.empty()); EXPECT_FALSE(s.empty());
s.read_bytes(data, 1024); s.read_bytes(data, 1024);
@ -1042,11 +988,8 @@ VOID TEST(KernelStreamTest, StreamEmpty)
*/ */
VOID TEST(KernelStreamTest, StreamRequire) VOID TEST(KernelStreamTest, StreamRequire)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_FALSE(s.require(1));
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
EXPECT_TRUE(s.require(1)); EXPECT_TRUE(s.require(1));
EXPECT_TRUE(s.require(1024)); EXPECT_TRUE(s.require(1024));
@ -1062,10 +1005,8 @@ VOID TEST(KernelStreamTest, StreamRequire)
*/ */
VOID TEST(KernelStreamTest, StreamSkip) VOID TEST(KernelStreamTest, StreamSkip)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
EXPECT_EQ(0, s.pos()); EXPECT_EQ(0, s.pos());
s.skip(1); s.skip(1);
@ -1080,10 +1021,8 @@ VOID TEST(KernelStreamTest, StreamSkip)
*/ */
VOID TEST(KernelStreamTest, StreamRead1Bytes) VOID TEST(KernelStreamTest, StreamRead1Bytes)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
data[0] = 0x12; data[0] = 0x12;
data[99] = 0x13; data[99] = 0x13;
@ -1101,10 +1040,8 @@ VOID TEST(KernelStreamTest, StreamRead1Bytes)
*/ */
VOID TEST(KernelStreamTest, StreamRead2Bytes) VOID TEST(KernelStreamTest, StreamRead2Bytes)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
data[0] = 0x01; data[0] = 0x01;
data[1] = 0x02; data[1] = 0x02;
@ -1130,10 +1067,8 @@ VOID TEST(KernelStreamTest, StreamRead2Bytes)
*/ */
VOID TEST(KernelStreamTest, StreamRead3Bytes) VOID TEST(KernelStreamTest, StreamRead3Bytes)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
data[0] = 0x01; data[0] = 0x01;
data[1] = 0x02; data[1] = 0x02;
@ -1159,10 +1094,8 @@ VOID TEST(KernelStreamTest, StreamRead3Bytes)
*/ */
VOID TEST(KernelStreamTest, StreamRead4Bytes) VOID TEST(KernelStreamTest, StreamRead4Bytes)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
data[0] = 0x01; data[0] = 0x01;
data[1] = 0x02; data[1] = 0x02;
@ -1188,10 +1121,8 @@ VOID TEST(KernelStreamTest, StreamRead4Bytes)
*/ */
VOID TEST(KernelStreamTest, StreamRead8Bytes) VOID TEST(KernelStreamTest, StreamRead8Bytes)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
data[0] = 0x01; data[0] = 0x01;
data[1] = 0x02; data[1] = 0x02;
@ -1227,10 +1158,8 @@ VOID TEST(KernelStreamTest, StreamRead8Bytes)
*/ */
VOID TEST(KernelStreamTest, StreamReadString) VOID TEST(KernelStreamTest, StreamReadString)
{ {
SrsBuffer s;
char data[] = "Hello, world!"; char data[] = "Hello, world!";
SrsBuffer s(data, sizeof(data) - 1);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, sizeof(data) - 1));
string str = s.read_string(2); string str = s.read_string(2);
EXPECT_STREQ("He", str.c_str()); EXPECT_STREQ("He", str.c_str());
@ -1250,10 +1179,8 @@ VOID TEST(KernelStreamTest, StreamReadString)
*/ */
VOID TEST(KernelStreamTest, StreamReadBytes) VOID TEST(KernelStreamTest, StreamReadBytes)
{ {
SrsBuffer s;
char data[] = "Hello, world!"; char data[] = "Hello, world!";
SrsBuffer s(data, sizeof(data) - 1);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, sizeof(data) - 1));
char bytes[64]; char bytes[64];
s.read_bytes(bytes, 2); s.read_bytes(bytes, 2);
@ -1277,10 +1204,8 @@ VOID TEST(KernelStreamTest, StreamReadBytes)
*/ */
VOID TEST(KernelStreamTest, StreamWrite1Bytes) VOID TEST(KernelStreamTest, StreamWrite1Bytes)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
s.write_1bytes(0x10); s.write_1bytes(0x10);
s.write_1bytes(0x11); s.write_1bytes(0x11);
@ -1298,10 +1223,8 @@ VOID TEST(KernelStreamTest, StreamWrite1Bytes)
*/ */
VOID TEST(KernelStreamTest, StreamWrite2Bytes) VOID TEST(KernelStreamTest, StreamWrite2Bytes)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
s.write_2bytes(0x1011); s.write_2bytes(0x1011);
s.write_2bytes(0x1213); s.write_2bytes(0x1213);
@ -1322,10 +1245,8 @@ VOID TEST(KernelStreamTest, StreamWrite2Bytes)
*/ */
VOID TEST(KernelStreamTest, StreamWrite3Bytes) VOID TEST(KernelStreamTest, StreamWrite3Bytes)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
s.write_3bytes(0x101112); s.write_3bytes(0x101112);
s.write_3bytes(0x131415); s.write_3bytes(0x131415);
@ -1345,10 +1266,8 @@ VOID TEST(KernelStreamTest, StreamWrite3Bytes)
*/ */
VOID TEST(KernelStreamTest, StreamWrite4Bytes) VOID TEST(KernelStreamTest, StreamWrite4Bytes)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
s.write_4bytes(0x10111213); s.write_4bytes(0x10111213);
s.write_4bytes(0x14151617); s.write_4bytes(0x14151617);
@ -1367,10 +1286,8 @@ VOID TEST(KernelStreamTest, StreamWrite4Bytes)
*/ */
VOID TEST(KernelStreamTest, StreamWrite8Bytes) VOID TEST(KernelStreamTest, StreamWrite8Bytes)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
s.write_8bytes(0x1011121314151617LL); s.write_8bytes(0x1011121314151617LL);
s.write_8bytes(0x1819202122232425LL); s.write_8bytes(0x1819202122232425LL);
@ -1388,10 +1305,8 @@ VOID TEST(KernelStreamTest, StreamWrite8Bytes)
*/ */
VOID TEST(KernelStreamTest, StreamWriteString) VOID TEST(KernelStreamTest, StreamWriteString)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
char str[] = { char str[] = {
(char)0x10, (char)0x11, (char)0x12, (char)0x13, (char)0x10, (char)0x11, (char)0x12, (char)0x13,
@ -1416,10 +1331,8 @@ VOID TEST(KernelStreamTest, StreamWriteString)
*/ */
VOID TEST(KernelStreamTest, StreamWriteBytes) VOID TEST(KernelStreamTest, StreamWriteBytes)
{ {
SrsBuffer s;
char data[1024]; char data[1024];
SrsBuffer s(data, 1024);
EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
char str[] = { char str[] = {
(char)0x10, (char)0x11, (char)0x12, (char)0x13, (char)0x10, (char)0x11, (char)0x12, (char)0x13,
@ -1522,90 +1435,89 @@ VOID TEST(KernelUtilityTest, UtilityString)
VOID TEST(KernelUtility, AvcUev) VOID TEST(KernelUtility, AvcUev)
{ {
int32_t v; int32_t v;
SrsBuffer buf;
SrsBitBuffer bb; SrsBitBuffer bb;
char data[32]; char data[32];
if (true) { if (true) {
data[0] = 0xff; data[0] = 0xff;
buf.initialize((char*)data, 1); bb.initialize(&buf); v = 1; SrsBuffer buf((char*)data, 1); bb.initialize(&buf); v = 1;
srs_avc_nalu_read_uev(&bb, v); srs_avc_nalu_read_uev(&bb, v);
EXPECT_EQ(0, v); EXPECT_EQ(0, v);
} }
if (true) { if (true) {
data[0] = 0x40; data[0] = 0x40;
buf.initialize((char*)data, 1); bb.initialize(&buf); v = 0; SrsBuffer buf((char*)data, 1); bb.initialize(&buf); v = 0;
srs_avc_nalu_read_uev(&bb, v); srs_avc_nalu_read_uev(&bb, v);
EXPECT_EQ(1, v); EXPECT_EQ(1, v);
} }
if (true) { if (true) {
data[0] = 0x60; data[0] = 0x60;
buf.initialize((char*)data, 1); bb.initialize(&buf); v = 0; SrsBuffer buf((char*)data, 1); bb.initialize(&buf); v = 0;
srs_avc_nalu_read_uev(&bb, v); srs_avc_nalu_read_uev(&bb, v);
EXPECT_EQ(2, v); EXPECT_EQ(2, v);
} }
if (true) { if (true) {
data[0] = 0x20; data[0] = 0x20;
buf.initialize((char*)data, 1); bb.initialize(&buf); v = 0; SrsBuffer buf((char*)data, 1); bb.initialize(&buf); v = 0;
srs_avc_nalu_read_uev(&bb, v); srs_avc_nalu_read_uev(&bb, v);
EXPECT_EQ(3, v); EXPECT_EQ(3, v);
} }
if (true) { if (true) {
data[0] = 0x28; data[0] = 0x28;
buf.initialize((char*)data, 1); bb.initialize(&buf); v = 0; SrsBuffer buf((char*)data, 1); bb.initialize(&buf); v = 0;
srs_avc_nalu_read_uev(&bb, v); srs_avc_nalu_read_uev(&bb, v);
EXPECT_EQ(4, v); EXPECT_EQ(4, v);
} }
if (true) { if (true) {
data[0] = 0x30; data[0] = 0x30;
buf.initialize((char*)data, 1); bb.initialize(&buf); v = 0; SrsBuffer buf((char*)data, 1); bb.initialize(&buf); v = 0;
srs_avc_nalu_read_uev(&bb, v); srs_avc_nalu_read_uev(&bb, v);
EXPECT_EQ(5, v); EXPECT_EQ(5, v);
} }
if (true) { if (true) {
data[0] = 0x38; data[0] = 0x38;
buf.initialize((char*)data, 1); bb.initialize(&buf); v = 0; SrsBuffer buf((char*)data, 1); bb.initialize(&buf); v = 0;
srs_avc_nalu_read_uev(&bb, v); srs_avc_nalu_read_uev(&bb, v);
EXPECT_EQ(6, v); EXPECT_EQ(6, v);
} }
if (true) { if (true) {
data[0] = 0x10; data[0] = 0x10;
buf.initialize((char*)data, 1); bb.initialize(&buf); v = 0; SrsBuffer buf((char*)data, 1); bb.initialize(&buf); v = 0;
srs_avc_nalu_read_uev(&bb, v); srs_avc_nalu_read_uev(&bb, v);
EXPECT_EQ(7, v); EXPECT_EQ(7, v);
} }
if (true) { if (true) {
data[0] = 0x12; data[0] = 0x12;
buf.initialize((char*)data, 1); bb.initialize(&buf); v = 0; SrsBuffer buf((char*)data, 1); bb.initialize(&buf); v = 0;
srs_avc_nalu_read_uev(&bb, v); srs_avc_nalu_read_uev(&bb, v);
EXPECT_EQ(8, v); EXPECT_EQ(8, v);
} }
if (true) { if (true) {
data[0] = 0x14; data[0] = 0x14;
buf.initialize((char*)data, 1); bb.initialize(&buf); v = 0; SrsBuffer buf((char*)data, 1); bb.initialize(&buf); v = 0;
srs_avc_nalu_read_uev(&bb, v); srs_avc_nalu_read_uev(&bb, v);
EXPECT_EQ(9, v); EXPECT_EQ(9, v);
} }
if (true) { if (true) {
data[0] = 0x01; data[1] = 0x12; data[0] = 0x01; data[1] = 0x12;
buf.initialize((char*)data, 2); bb.initialize(&buf); v = 0; SrsBuffer buf((char*)data, 2); bb.initialize(&buf); v = 0;
srs_avc_nalu_read_uev(&bb, v); srs_avc_nalu_read_uev(&bb, v);
EXPECT_EQ(128-1+9, v); EXPECT_EQ(128-1+9, v);
} }
if (true) { if (true) {
data[0] = 0x00; data[1] = 0x91; data[2] = 0x00; data[0] = 0x00; data[1] = 0x91; data[2] = 0x00;
buf.initialize((char*)data, 3); bb.initialize(&buf); v = 0; SrsBuffer buf((char*)data, 3); bb.initialize(&buf); v = 0;
srs_avc_nalu_read_uev(&bb, v); srs_avc_nalu_read_uev(&bb, v);
EXPECT_EQ(256-1+0x22, v); EXPECT_EQ(256-1+0x22, v);
} }

12
trunk/src/utest/srs_utest_kernel.hpp
View file

@ -41,7 +41,7 @@ public:
MockBufferReader(const char* data); MockBufferReader(const char* data);
virtual ~MockBufferReader(); virtual ~MockBufferReader();
public: public:
virtual int read(void* buf, size_t size, ssize_t* nread); virtual srs_error_t read(void* buf, size_t size, ssize_t* nread);
}; };
class MockSrsFileWriter : public SrsFileWriter class MockSrsFileWriter : public SrsFileWriter
@ -53,13 +53,13 @@ public:
MockSrsFileWriter(); MockSrsFileWriter();
virtual ~MockSrsFileWriter(); virtual ~MockSrsFileWriter();
public: public:
virtual int open(std::string file); virtual srs_error_t open(std::string file);
virtual void close(); virtual void close();
public: public:
virtual bool is_open(); virtual bool is_open();
virtual int64_t tellg(); virtual int64_t tellg();
public: public:
virtual int write(void* buf, size_t count, ssize_t* pnwrite); virtual srs_error_t write(void* buf, size_t count, ssize_t* pnwrite);
// for mock // for mock
public: public:
void mock_reset_offset(); void mock_reset_offset();
@ -75,7 +75,7 @@ public:
MockSrsFileReader(); MockSrsFileReader();
virtual ~MockSrsFileReader(); virtual ~MockSrsFileReader();
public: public:
virtual int open(std::string file); virtual srs_error_t open(std::string file);
virtual void close(); virtual void close();
public: public:
virtual bool is_open(); virtual bool is_open();
@ -84,8 +84,8 @@ public:
virtual int64_t seek2(int64_t offset); virtual int64_t seek2(int64_t offset);
virtual int64_t filesize(); virtual int64_t filesize();
public: public:
virtual int read(void* buf, size_t count, ssize_t* pnread); virtual srs_error_t read(void* buf, size_t count, ssize_t* pnread);
virtual int lseek(off_t offset, int whence, off_t* seeked); virtual srs_error_t lseek(off_t offset, int whence, off_t* seeked);
// for mock // for mock
public: public:
// append data to current offset, modify the offset and size. // append data to current offset, modify the offset and size.

42
trunk/src/utest/srs_utest_protocol.cpp
View file

@ -47,14 +47,14 @@ bool MockEmptyIO::is_never_timeout(int64_t /*tm*/)
return true; return true;
} }
int MockEmptyIO::read_fully(void* /*buf*/, size_t /*size*/, ssize_t* /*nread*/) srs_error_t MockEmptyIO::read_fully(void* /*buf*/, size_t /*size*/, ssize_t* /*nread*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int MockEmptyIO::write(void* /*buf*/, size_t /*size*/, ssize_t* /*nwrite*/) srs_error_t MockEmptyIO::write(void* /*buf*/, size_t /*size*/, ssize_t* /*nwrite*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
void MockEmptyIO::set_recv_timeout(int64_t /*tm*/) void MockEmptyIO::set_recv_timeout(int64_t /*tm*/)
@ -85,14 +85,14 @@ int64_t MockEmptyIO::get_send_bytes()
return 0; return 0;
} }
int MockEmptyIO::writev(const iovec */*iov*/, int /*iov_size*/, ssize_t* /*nwrite*/) srs_error_t MockEmptyIO::writev(const iovec */*iov*/, int /*iov_size*/, ssize_t* /*nwrite*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int MockEmptyIO::read(void* /*buf*/, size_t /*size*/, ssize_t* /*nread*/) srs_error_t MockEmptyIO::read(void* /*buf*/, size_t /*size*/, ssize_t* /*nread*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
MockBufferIO::MockBufferIO() MockBufferIO::MockBufferIO()
@ -110,10 +110,10 @@ bool MockBufferIO::is_never_timeout(int64_t tm)
return tm == SRS_CONSTS_NO_TMMS; return tm == SRS_CONSTS_NO_TMMS;
} }
int MockBufferIO::read_fully(void* buf, size_t size, ssize_t* nread) srs_error_t MockBufferIO::read_fully(void* buf, size_t size, ssize_t* nread)
{ {
if (in_buffer.length() < (int)size) { if (in_buffer.length() < (int)size) {
return ERROR_SOCKET_READ; return srs_error_new(ERROR_SOCKET_READ, "read");
} }
memcpy(buf, in_buffer.bytes(), size); memcpy(buf, in_buffer.bytes(), size);
@ -122,17 +122,17 @@ int MockBufferIO::read_fully(void* buf, size_t size, ssize_t* nread)
*nread = size; *nread = size;
} }
in_buffer.erase(size); in_buffer.erase(size);
return ERROR_SUCCESS; return srs_success;
} }
int MockBufferIO::write(void* buf, size_t size, ssize_t* nwrite) srs_error_t MockBufferIO::write(void* buf, size_t size, ssize_t* nwrite)
{ {
sbytes += size; sbytes += size;
if (nwrite) { if (nwrite) {
*nwrite = size; *nwrite = size;
} }
out_buffer.append((char*)buf, size); out_buffer.append((char*)buf, size);
return ERROR_SUCCESS; return srs_success;
} }
void MockBufferIO::set_recv_timeout(int64_t tm) void MockBufferIO::set_recv_timeout(int64_t tm)
@ -165,17 +165,17 @@ int64_t MockBufferIO::get_send_bytes()
return sbytes; return sbytes;
} }
int MockBufferIO::writev(const iovec *iov, int iov_size, ssize_t* nwrite) srs_error_t MockBufferIO::writev(const iovec *iov, int iov_size, ssize_t* nwrite)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
ssize_t total = 0; ssize_t total = 0;
for (int i = 0; i <iov_size; i++) { for (int i = 0; i <iov_size; i++) {
const iovec& pi = iov[i]; const iovec& pi = iov[i];
ssize_t writen = 0; ssize_t writen = 0;
if ((ret = write(pi.iov_base, pi.iov_len, &writen)) != ERROR_SUCCESS) { if ((err = write(pi.iov_base, pi.iov_len, &writen)) != srs_success) {
return ret; return err;
} }
total += writen; total += writen;
} }
@ -185,13 +185,13 @@ int MockBufferIO::writev(const iovec *iov, int iov_size, ssize_t* nwrite)
if (nwrite) { if (nwrite) {
*nwrite = total; *nwrite = total;
} }
return ret; return err;
} }
int MockBufferIO::read(void* buf, size_t size, ssize_t* nread) srs_error_t MockBufferIO::read(void* buf, size_t size, ssize_t* nread)
{ {
if (in_buffer.length() <= 0) { if (in_buffer.length() <= 0) {
return ERROR_SOCKET_READ; return srs_error_new(ERROR_SOCKET_READ, "read");
} }
size_t available = srs_min(in_buffer.length(), (int)size); size_t available = srs_min(in_buffer.length(), (int)size);
@ -202,7 +202,7 @@ int MockBufferIO::read(void* buf, size_t size, ssize_t* nread)
*nread = available; *nread = available;
} }
in_buffer.erase(available); in_buffer.erase(available);
return ERROR_SUCCESS; return srs_success;
} }
#ifdef ENABLE_UTEST_PROTOCOL #ifdef ENABLE_UTEST_PROTOCOL

16
trunk/src/utest/srs_utest_protocol.hpp
View file

@ -52,8 +52,8 @@ public:
virtual bool is_never_timeout(int64_t tm); virtual bool is_never_timeout(int64_t tm);
// for handshake. // for handshake.
public: public:
virtual int read_fully(void* buf, size_t size, ssize_t* nread); virtual srs_error_t read_fully(void* buf, size_t size, ssize_t* nread);
virtual int write(void* buf, size_t size, ssize_t* nwrite); virtual srs_error_t write(void* buf, size_t size, ssize_t* nwrite);
// for protocol // for protocol
public: public:
virtual void set_recv_timeout(int64_t tm); virtual void set_recv_timeout(int64_t tm);
@ -64,10 +64,10 @@ public:
virtual void set_send_timeout(int64_t tm); virtual void set_send_timeout(int64_t tm);
virtual int64_t get_send_timeout(); virtual int64_t get_send_timeout();
virtual int64_t get_send_bytes(); virtual int64_t get_send_bytes();
virtual int writev(const iovec *iov, int iov_size, ssize_t* nwrite); virtual srs_error_t writev(const iovec *iov, int iov_size, ssize_t* nwrite);
// for protocol/amf0/msg-codec // for protocol/amf0/msg-codec
public: public:
virtual int read(void* buf, size_t size, ssize_t* nread); virtual srs_error_t read(void* buf, size_t size, ssize_t* nread);
}; };
class MockBufferIO : public ISrsProtocolReaderWriter class MockBufferIO : public ISrsProtocolReaderWriter
@ -91,8 +91,8 @@ public:
virtual bool is_never_timeout(int64_t tm); virtual bool is_never_timeout(int64_t tm);
// for handshake. // for handshake.
public: public:
virtual int read_fully(void* buf, size_t size, ssize_t* nread); virtual srs_error_t read_fully(void* buf, size_t size, ssize_t* nread);
virtual int write(void* buf, size_t size, ssize_t* nwrite); virtual srs_error_t write(void* buf, size_t size, ssize_t* nwrite);
// for protocol // for protocol
public: public:
virtual void set_recv_timeout(int64_t tm); virtual void set_recv_timeout(int64_t tm);
@ -103,10 +103,10 @@ public:
virtual void set_send_timeout(int64_t tm); virtual void set_send_timeout(int64_t tm);
virtual int64_t get_send_timeout(); virtual int64_t get_send_timeout();
virtual int64_t get_send_bytes(); virtual int64_t get_send_bytes();
virtual int writev(const iovec *iov, int iov_size, ssize_t* nwrite); virtual srs_error_t writev(const iovec *iov, int iov_size, ssize_t* nwrite);
// for protocol/amf0/msg-codec // for protocol/amf0/msg-codec
public: public:
virtual int read(void* buf, size_t size, ssize_t* nread); virtual srs_error_t read(void* buf, size_t size, ssize_t* nread);
}; };
#endif #endif