From 204ef041dac50ab98f47a1f2c3f7a64d5f0e9ba6 Mon Sep 17 00:00:00 2001 From: winlin Date: Sun, 31 Dec 2017 12:11:48 +0800 Subject: [PATCH] For #913, Kernel MP4 FLV HTTP support complex error. --- trunk/src/app/srs_app_http_stream.cpp | 238 ++-- trunk/src/app/srs_app_http_stream.hpp | 72 +- trunk/src/kernel/srs_kernel_aac.cpp | 55 +- trunk/src/kernel/srs_kernel_aac.hpp | 6 +- trunk/src/kernel/srs_kernel_buffer.cpp | 45 +- trunk/src/kernel/srs_kernel_buffer.hpp | 22 +- trunk/src/kernel/srs_kernel_codec.cpp | 117 +- trunk/src/kernel/srs_kernel_codec.hpp | 2 - trunk/src/kernel/srs_kernel_file.cpp | 95 +- trunk/src/kernel/srs_kernel_file.hpp | 16 +- trunk/src/kernel/srs_kernel_flv.cpp | 330 ++--- trunk/src/kernel/srs_kernel_flv.hpp | 53 +- trunk/src/kernel/srs_kernel_io.hpp | 8 +- trunk/src/kernel/srs_kernel_mp3.cpp | 52 +- trunk/src/kernel/srs_kernel_mp3.hpp | 8 +- trunk/src/kernel/srs_kernel_mp4.cpp | 1595 +++++++++++------------ trunk/src/kernel/srs_kernel_mp4.hpp | 247 ++-- trunk/src/kernel/srs_kernel_ts.cpp | 34 +- trunk/src/kernel/srs_kernel_utility.cpp | 20 +- trunk/src/kernel/srs_kernel_utility.hpp | 4 +- trunk/src/protocol/srs_http_stack.cpp | 36 +- trunk/src/protocol/srs_http_stack.hpp | 12 +- trunk/src/protocol/srs_kafka_stack.cpp | 2 +- 23 files changed, 1411 insertions(+), 1658 deletions(-) diff --git a/trunk/src/app/srs_app_http_stream.cpp b/trunk/src/app/srs_app_http_stream.cpp index 5d115bba0..4548c5bff 100755 --- a/trunk/src/app/srs_app_http_stream.cpp +++ b/trunk/src/app/srs_app_http_stream.cpp @@ -74,15 +74,13 @@ SrsBufferCache::~SrsBufferCache() srs_freep(req); } -int SrsBufferCache::update(SrsSource* s, SrsRequest* r) +srs_error_t SrsBufferCache::update(SrsSource* s, SrsRequest* r) { - int ret = ERROR_SUCCESS; - srs_freep(req); req = r->copy(); source = s; - return ret; + return srs_success; } srs_error_t SrsBufferCache::start() @@ -96,28 +94,22 @@ srs_error_t SrsBufferCache::start() return err; } -int SrsBufferCache::dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter) +srs_error_t SrsBufferCache::dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; if (fast_cache <= 0) { - srs_info("http: ignore dump fast cache."); - return ret; + return err; } // the jitter is get from SrsSource, which means the time_jitter of vhost. if ((err = queue->dump_packets(consumer, false, jitter)) != srs_success) { - // TODO: FIXME: Use error - ret = srs_error_code(err); - srs_freep(err); - return ret; + return srs_error_wrap(err, "dump packets"); } - srs_trace("http: dump cache %d msgs, duration=%dms, cache=%.2fs", - queue->size(), queue->duration(), fast_cache); + srs_trace("http: dump cache %d msgs, duration=%dms, cache=%.2fs", queue->size(), queue->duration(), fast_cache); - return ret; + return err; } srs_error_t SrsBufferCache::cycle() @@ -203,42 +195,42 @@ SrsTsStreamEncoder::~SrsTsStreamEncoder() srs_freep(enc); } -int SrsTsStreamEncoder::initialize(SrsFileWriter* w, SrsBufferCache* /*c*/) +srs_error_t SrsTsStreamEncoder::initialize(SrsFileWriter* w, SrsBufferCache* /*c*/) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; if ((err = enc->initialize(w)) != srs_success) { - // TODO: FIXME: Use error - ret = srs_error_code(err); - srs_freep(err); - return ret; + return srs_error_wrap(err, "init encoder"); } - return ret; + return err; } -int SrsTsStreamEncoder::write_audio(int64_t timestamp, char* data, int size) +srs_error_t SrsTsStreamEncoder::write_audio(int64_t timestamp, char* data, int size) { - srs_error_t err = enc->write_audio(timestamp, data, size); - // TODO: FIXME: Use error - int ret = srs_error_code(err); - srs_freep(err); - return ret; + srs_error_t err = srs_success; + + if ((err = enc->write_audio(timestamp, data, size)) != srs_success) { + return srs_error_wrap(err, "write audio"); + } + + return err; } -int SrsTsStreamEncoder::write_video(int64_t timestamp, char* data, int size) +srs_error_t SrsTsStreamEncoder::write_video(int64_t timestamp, char* data, int size) { - srs_error_t err = enc->write_video(timestamp, data, size); - // TODO: FIXME: Use error - int ret = srs_error_code(err); - srs_freep(err); - return ret; + srs_error_t err = srs_success; + + if ((err = enc->write_video(timestamp, data, size)) != srs_success) { + return srs_error_wrap(err, "write video"); + } + + return err; } -int SrsTsStreamEncoder::write_metadata(int64_t /*timestamp*/, char* /*data*/, int /*size*/) +srs_error_t SrsTsStreamEncoder::write_metadata(int64_t /*timestamp*/, char* /*data*/, int /*size*/) { - return ERROR_SUCCESS; + return srs_success; } bool SrsTsStreamEncoder::has_cache() @@ -247,10 +239,10 @@ bool SrsTsStreamEncoder::has_cache() return false; } -int SrsTsStreamEncoder::dump_cache(SrsConsumer* /*consumer*/, SrsRtmpJitterAlgorithm /*jitter*/) +srs_error_t SrsTsStreamEncoder::dump_cache(SrsConsumer* /*consumer*/, SrsRtmpJitterAlgorithm /*jitter*/) { // for ts stream, ignore cache. - return ERROR_SUCCESS; + return srs_success; } SrsFlvStreamEncoder::SrsFlvStreamEncoder() @@ -263,33 +255,33 @@ SrsFlvStreamEncoder::~SrsFlvStreamEncoder() srs_freep(enc); } -int SrsFlvStreamEncoder::initialize(SrsFileWriter* w, SrsBufferCache* /*c*/) +srs_error_t SrsFlvStreamEncoder::initialize(SrsFileWriter* w, SrsBufferCache* /*c*/) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = enc->initialize(w)) != ERROR_SUCCESS) { - return ret; + if ((err = enc->initialize(w)) != srs_success) { + return srs_error_wrap(err, "init encoder"); } // write flv header. - if ((ret = enc->write_header()) != ERROR_SUCCESS) { - return ret; + if ((err = enc->write_header()) != srs_success) { + return srs_error_wrap(err, "write header"); } - return ret; + return err; } -int SrsFlvStreamEncoder::write_audio(int64_t timestamp, char* data, int size) +srs_error_t SrsFlvStreamEncoder::write_audio(int64_t timestamp, char* data, int size) { return enc->write_audio(timestamp, data, size); } -int SrsFlvStreamEncoder::write_video(int64_t timestamp, char* data, int size) +srs_error_t SrsFlvStreamEncoder::write_video(int64_t timestamp, char* data, int size) { return enc->write_video(timestamp, data, size); } -int SrsFlvStreamEncoder::write_metadata(int64_t timestamp, char* data, int size) +srs_error_t SrsFlvStreamEncoder::write_metadata(int64_t timestamp, char* data, int size) { return enc->write_metadata(SrsFrameTypeScript, data, size); } @@ -300,10 +292,10 @@ bool SrsFlvStreamEncoder::has_cache() return false; } -int SrsFlvStreamEncoder::dump_cache(SrsConsumer* /*consumer*/, SrsRtmpJitterAlgorithm /*jitter*/) +srs_error_t SrsFlvStreamEncoder::dump_cache(SrsConsumer* /*consumer*/, SrsRtmpJitterAlgorithm /*jitter*/) { // for flv stream, ignore cache. - return ERROR_SUCCESS; + return srs_success; } #ifdef SRS_PERF_FAST_FLV_ENCODER @@ -315,7 +307,7 @@ SrsFastFlvStreamEncoder::~SrsFastFlvStreamEncoder() { } -int SrsFastFlvStreamEncoder::write_tags(SrsSharedPtrMessage** msgs, int count) +srs_error_t SrsFastFlvStreamEncoder::write_tags(SrsSharedPtrMessage** msgs, int count) { return enc->write_tags(msgs, count); } @@ -332,34 +324,34 @@ SrsAacStreamEncoder::~SrsAacStreamEncoder() srs_freep(enc); } -int SrsAacStreamEncoder::initialize(SrsFileWriter* w, SrsBufferCache* c) +srs_error_t SrsAacStreamEncoder::initialize(SrsFileWriter* w, SrsBufferCache* c) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; cache = c; - if ((ret = enc->initialize(w)) != ERROR_SUCCESS) { - return ret; + if ((err = enc->initialize(w)) != srs_success) { + return srs_error_wrap(err, "init encoder"); } - return ret; + return err; } -int SrsAacStreamEncoder::write_audio(int64_t timestamp, char* data, int size) +srs_error_t SrsAacStreamEncoder::write_audio(int64_t timestamp, char* data, int size) { return enc->write_audio(timestamp, data, size); } -int SrsAacStreamEncoder::write_video(int64_t /*timestamp*/, char* /*data*/, int /*size*/) +srs_error_t SrsAacStreamEncoder::write_video(int64_t /*timestamp*/, char* /*data*/, int /*size*/) { // aac ignore any flv video. - return ERROR_SUCCESS; + return srs_success; } -int SrsAacStreamEncoder::write_metadata(int64_t /*timestamp*/, char* /*data*/, int /*size*/) +srs_error_t SrsAacStreamEncoder::write_metadata(int64_t /*timestamp*/, char* /*data*/, int /*size*/) { // aac ignore any flv metadata. - return ERROR_SUCCESS; + return srs_success; } bool SrsAacStreamEncoder::has_cache() @@ -367,7 +359,7 @@ bool SrsAacStreamEncoder::has_cache() return true; } -int SrsAacStreamEncoder::dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter) +srs_error_t SrsAacStreamEncoder::dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter) { srs_assert(cache); return cache->dump_cache(consumer, jitter); @@ -384,38 +376,38 @@ SrsMp3StreamEncoder::~SrsMp3StreamEncoder() srs_freep(enc); } -int SrsMp3StreamEncoder::initialize(SrsFileWriter* w, SrsBufferCache* c) +srs_error_t SrsMp3StreamEncoder::initialize(SrsFileWriter* w, SrsBufferCache* c) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; cache = c; - if ((ret = enc->initialize(w)) != ERROR_SUCCESS) { - return ret; + if ((err = enc->initialize(w)) != srs_success) { + return srs_error_wrap(err, "init encoder"); } - if ((ret = enc->write_header()) != ERROR_SUCCESS) { - return ret; + if ((err = enc->write_header()) != srs_success) { + return srs_error_wrap(err, "init encoder"); } - return ret; + return err; } -int SrsMp3StreamEncoder::write_audio(int64_t timestamp, char* data, int size) +srs_error_t SrsMp3StreamEncoder::write_audio(int64_t timestamp, char* data, int size) { return enc->write_audio(timestamp, data, size); } -int SrsMp3StreamEncoder::write_video(int64_t /*timestamp*/, char* /*data*/, int /*size*/) +srs_error_t SrsMp3StreamEncoder::write_video(int64_t /*timestamp*/, char* /*data*/, int /*size*/) { // mp3 ignore any flv video. - return ERROR_SUCCESS; + return srs_success; } -int SrsMp3StreamEncoder::write_metadata(int64_t /*timestamp*/, char* /*data*/, int /*size*/) +srs_error_t SrsMp3StreamEncoder::write_metadata(int64_t /*timestamp*/, char* /*data*/, int /*size*/) { // mp3 ignore any flv metadata. - return ERROR_SUCCESS; + return srs_success; } bool SrsMp3StreamEncoder::has_cache() @@ -423,7 +415,7 @@ bool SrsMp3StreamEncoder::has_cache() return true; } -int SrsMp3StreamEncoder::dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter) +srs_error_t SrsMp3StreamEncoder::dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter) { srs_assert(cache); return cache->dump_cache(consumer, jitter); @@ -438,9 +430,9 @@ SrsBufferWriter::~SrsBufferWriter() { } -int SrsBufferWriter::open(std::string /*file*/) +srs_error_t SrsBufferWriter::open(std::string /*file*/) { - return ERROR_SUCCESS; + return srs_success; } void SrsBufferWriter::close() @@ -457,7 +449,7 @@ int64_t SrsBufferWriter::tellg() return 0; } -int SrsBufferWriter::write(void* buf, size_t count, ssize_t* pnwrite) +srs_error_t SrsBufferWriter::write(void* buf, size_t count, ssize_t* pnwrite) { if (pnwrite) { *pnwrite = count; @@ -465,7 +457,7 @@ int SrsBufferWriter::write(void* buf, size_t count, ssize_t* pnwrite) return writer->write((char*)buf, (int)count); } -int SrsBufferWriter::writev(const iovec* iov, int iovcnt, ssize_t* pnwrite) +srs_error_t SrsBufferWriter::writev(const iovec* iov, int iovcnt, ssize_t* pnwrite) { return writer->writev(iov, iovcnt, pnwrite); } @@ -482,20 +474,17 @@ SrsLiveStream::~SrsLiveStream() srs_freep(req); } -int SrsLiveStream::update(SrsSource* s, SrsRequest* r) +srs_error_t SrsLiveStream::update(SrsSource* s, SrsRequest* r) { - int ret = ERROR_SUCCESS; - srs_freep(req); source = s; req = r->copy(); - return ret; + return srs_success; } srs_error_t SrsLiveStream::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; ISrsBufferEncoder* enc = NULL; @@ -537,20 +526,20 @@ srs_error_t SrsLiveStream::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage // update the statistic when source disconveried. SrsStatistic* stat = SrsStatistic::instance(); - if ((ret = stat->on_client(_srs_context->get_id(), req, NULL, SrsRtmpConnPlay)) != ERROR_SUCCESS) { - return srs_error_new(ret, "stat on client"); + if ((err = stat->on_client(_srs_context->get_id(), req, NULL, SrsRtmpConnPlay)) != srs_success) { + return srs_error_wrap(err, "stat on client"); } // the memory writer. SrsBufferWriter writer(w); - if ((ret = enc->initialize(&writer, cache)) != ERROR_SUCCESS) { - return srs_error_new(ret, "init encoder"); + if ((err = enc->initialize(&writer, cache)) != srs_success) { + return srs_error_wrap(err, "init encoder"); } // if gop cache enabled for encoder, dump to consumer. if (enc->has_cache()) { - if ((ret = enc->dump_cache(consumer, source->jitter())) != ERROR_SUCCESS) { - return srs_error_new(ret, "encoder dump cache"); + if ((err = enc->dump_cache(consumer, source->jitter())) != srs_success) { + return srs_error_wrap(err, "encoder dump cache"); } } @@ -603,12 +592,12 @@ srs_error_t SrsLiveStream::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage // sendout all messages. #ifdef SRS_PERF_FAST_FLV_ENCODER if (ffe) { - ret = ffe->write_tags(msgs.msgs, count); + err = ffe->write_tags(msgs.msgs, count); } else { - ret = streaming_send_messages(enc, msgs.msgs, count); + err = streaming_send_messages(enc, msgs.msgs, count); } #else - ret = streaming_send_messages(enc, msgs.msgs, count); + err = streaming_send_messages(enc, msgs.msgs, count); #endif // free the messages. @@ -618,8 +607,8 @@ srs_error_t SrsLiveStream::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage } // check send error code. - if (ret != ERROR_SUCCESS) { - return srs_error_new(ret, "send messages"); + if (err != srs_success) { + return srs_error_wrap(err, "send messages"); } } @@ -720,21 +709,19 @@ SrsHttpStreamServer::~SrsHttpStreamServer() srs_error_t SrsHttpStreamServer::initialize() { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; // remux rtmp to flv live streaming - if ((ret = initialize_flv_streaming()) != ERROR_SUCCESS) { - return srs_error_new(ret, "http flv stream"); + if ((err = initialize_flv_streaming()) != srs_success) { + return srs_error_wrap(err, "http flv stream"); } return err; } // TODO: FIXME: rename for HTTP FLV mount. -int SrsHttpStreamServer::http_mount(SrsSource* s, SrsRequest* r) +srs_error_t SrsHttpStreamServer::http_mount(SrsSource* s, SrsRequest* r) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; // the id to identify stream. @@ -783,22 +770,12 @@ int SrsHttpStreamServer::http_mount(SrsSource* s, SrsRequest* r) // for the thread will cause thread switch context. // @see https://github.com/ossrs/srs/issues/404 if ((err = mux.handle(mount, entry->stream)) != srs_success) { - // TODO: FIXME: Use error. - ret = srs_error_code(err); - srs_freep(err); - - srs_error("http: mount flv stream for vhost=%s failed. ret=%d", sid.c_str(), ret); - return ret; + return srs_error_wrap(err, "http: mount flv stream for vhost=%s failed", sid.c_str()); } // start http stream cache thread if ((err = entry->cache->start()) != srs_success) { - // TODO: FIXME: Use error - ret = srs_error_code(err); - srs_freep(err); - - srs_error("http: start stream cache failed. ret=%d", ret); - return ret; + return srs_error_wrap(err, "http: start stream cache failed"); } srs_trace("http: mount flv stream for vhost=%s, mount=%s", sid.c_str(), mount.c_str()); } else { @@ -809,10 +786,10 @@ int SrsHttpStreamServer::http_mount(SrsSource* s, SrsRequest* r) if (entry->stream) { entry->stream->entry->enabled = true; - return ret; + return err; } - return ret; + return err; } void SrsHttpStreamServer::http_unmount(SrsSource* s, SrsRequest* r) @@ -841,12 +818,11 @@ srs_error_t SrsHttpStreamServer::on_reload_vhost_added(string vhost) srs_error_t SrsHttpStreamServer::on_reload_vhost_http_remux_updated(string vhost) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; if (tflvs.find(vhost) == tflvs.end()) { - if ((ret = initialize_flv_entry(vhost)) != ERROR_SUCCESS) { - return srs_error_new(ret, "init flv entry"); + if ((err = initialize_flv_entry(vhost)) != srs_success) { + return srs_error_wrap(err, "init flv entry"); } // http mount need SrsRequest and SrsSource param, only create a mapping template entry @@ -882,8 +858,8 @@ srs_error_t SrsHttpStreamServer::on_reload_vhost_http_remux_updated(string vhost std::string sid = req->get_stream_url(); // remount stream. - if ((ret = http_mount(source, req)) != ERROR_SUCCESS) { - return srs_error_new(ret, "vhost %s http_remux reload failed", vhost.c_str()); + if ((err = http_mount(source, req)) != srs_success) { + return srs_error_wrap(err, "vhost %s http_remux reload failed", vhost.c_str()); } } else { // for without SrsRequest and SrsSource if stream is not played yet, do http mount automatically @@ -897,7 +873,6 @@ srs_error_t SrsHttpStreamServer::on_reload_vhost_http_remux_updated(string vhost srs_error_t SrsHttpStreamServer::hijack(ISrsHttpMessage* request, ISrsHttpHandler** ph) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; // when handler not the root, we think the handler is ok. @@ -986,8 +961,8 @@ srs_error_t SrsHttpStreamServer::hijack(ISrsHttpMessage* request, ISrsHttpHandle srs_assert(s != NULL); // create http streaming handler. - if ((ret = http_mount(s, r)) != ERROR_SUCCESS) { - return srs_error_new(ret, "http mount"); + if ((err = http_mount(s, r)) != srs_success) { + return srs_error_wrap(err, "http mount"); } // use the handler if exists. @@ -1006,9 +981,9 @@ srs_error_t SrsHttpStreamServer::hijack(ISrsHttpMessage* request, ISrsHttpHandle return err; } -int SrsHttpStreamServer::initialize_flv_streaming() +srs_error_t SrsHttpStreamServer::initialize_flv_streaming() { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; // http flv live stream mount for each vhost. SrsConfDirective* root = _srs_config->get_root(); @@ -1019,19 +994,20 @@ int SrsHttpStreamServer::initialize_flv_streaming() continue; } - if ((ret = initialize_flv_entry(conf->arg0())) != ERROR_SUCCESS) { - return ret; + if ((err = initialize_flv_entry(conf->arg0())) != srs_success) { + return srs_error_wrap(err, "init flv entries"); } } - return ret; + + return err; } -int SrsHttpStreamServer::initialize_flv_entry(std::string vhost) +srs_error_t SrsHttpStreamServer::initialize_flv_entry(std::string vhost) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (!_srs_config->get_vhost_http_remux_enabled(vhost)) { - return ret; + return err; } SrsLiveEntry* entry = new SrsLiveEntry(_srs_config->get_vhost_http_remux_mount(vhost)); @@ -1039,6 +1015,6 @@ int SrsHttpStreamServer::initialize_flv_entry(std::string vhost) tflvs[vhost] = entry; srs_trace("http flv live stream, vhost=%s, mount=%s", vhost.c_str(), entry->mount.c_str()); - return ret; + return err; } diff --git a/trunk/src/app/srs_app_http_stream.hpp b/trunk/src/app/srs_app_http_stream.hpp index 8eb94cc02..8ebf75919 100755 --- a/trunk/src/app/srs_app_http_stream.hpp +++ b/trunk/src/app/srs_app_http_stream.hpp @@ -50,10 +50,10 @@ private: public: SrsBufferCache(SrsSource* s, SrsRequest* r); virtual ~SrsBufferCache(); - virtual int update(SrsSource* s, SrsRequest* r); + virtual srs_error_t update(SrsSource* s, SrsRequest* r); public: virtual srs_error_t start(); - virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter); + virtual srs_error_t dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter); // interface ISrsEndlessThreadHandler. public: virtual srs_error_t cycle(); @@ -73,13 +73,13 @@ public: * @param w the writer to write to http response. * @param c the stream cache for audio stream fast startup. */ - virtual int initialize(SrsFileWriter* w, SrsBufferCache* c) = 0; + virtual srs_error_t initialize(SrsFileWriter* w, SrsBufferCache* c) = 0; /** * write rtmp video/audio/metadata. */ - virtual int write_audio(int64_t timestamp, char* data, int size) = 0; - virtual int write_video(int64_t timestamp, char* data, int size) = 0; - virtual int write_metadata(int64_t timestamp, char* data, int size) = 0; + virtual srs_error_t write_audio(int64_t timestamp, char* data, int size) = 0; + virtual srs_error_t write_video(int64_t timestamp, char* data, int size) = 0; + virtual srs_error_t write_metadata(int64_t timestamp, char* data, int size) = 0; public: /** * for some stream, for example, mp3 and aac, the audio stream, @@ -90,7 +90,7 @@ public: /** * dumps the cache of encoder to consumer. */ - virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter) = 0; + virtual srs_error_t dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter) = 0; }; /** @@ -104,13 +104,13 @@ public: SrsFlvStreamEncoder(); virtual ~SrsFlvStreamEncoder(); public: - virtual int initialize(SrsFileWriter* w, SrsBufferCache* c); - virtual int write_audio(int64_t timestamp, char* data, int size); - virtual int write_video(int64_t timestamp, char* data, int size); - virtual int write_metadata(int64_t timestamp, char* data, int size); + virtual srs_error_t initialize(SrsFileWriter* w, SrsBufferCache* c); + virtual srs_error_t write_audio(int64_t timestamp, char* data, int size); + virtual srs_error_t write_video(int64_t timestamp, char* data, int size); + virtual srs_error_t write_metadata(int64_t timestamp, char* data, int size); public: virtual bool has_cache(); - virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter); + virtual srs_error_t dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter); }; #ifdef SRS_PERF_FAST_FLV_ENCODER @@ -127,7 +127,7 @@ public: /** * write the tags in a time. */ - virtual int write_tags(SrsSharedPtrMessage** msgs, int count); + virtual srs_error_t write_tags(SrsSharedPtrMessage** msgs, int count); }; #endif @@ -142,13 +142,13 @@ public: SrsTsStreamEncoder(); virtual ~SrsTsStreamEncoder(); public: - virtual int initialize(SrsFileWriter* w, SrsBufferCache* c); - virtual int write_audio(int64_t timestamp, char* data, int size); - virtual int write_video(int64_t timestamp, char* data, int size); - virtual int write_metadata(int64_t timestamp, char* data, int size); + virtual srs_error_t initialize(SrsFileWriter* w, SrsBufferCache* c); + virtual srs_error_t write_audio(int64_t timestamp, char* data, int size); + virtual srs_error_t write_video(int64_t timestamp, char* data, int size); + virtual srs_error_t write_metadata(int64_t timestamp, char* data, int size); public: virtual bool has_cache(); - virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter); + virtual srs_error_t dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter); }; /** @@ -163,13 +163,13 @@ public: SrsAacStreamEncoder(); virtual ~SrsAacStreamEncoder(); public: - virtual int initialize(SrsFileWriter* w, SrsBufferCache* c); - virtual int write_audio(int64_t timestamp, char* data, int size); - virtual int write_video(int64_t timestamp, char* data, int size); - virtual int write_metadata(int64_t timestamp, char* data, int size); + virtual srs_error_t initialize(SrsFileWriter* w, SrsBufferCache* c); + virtual srs_error_t write_audio(int64_t timestamp, char* data, int size); + virtual srs_error_t write_video(int64_t timestamp, char* data, int size); + virtual srs_error_t write_metadata(int64_t timestamp, char* data, int size); public: virtual bool has_cache(); - virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter); + virtual srs_error_t dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter); }; /** @@ -184,13 +184,13 @@ public: SrsMp3StreamEncoder(); virtual ~SrsMp3StreamEncoder(); public: - virtual int initialize(SrsFileWriter* w, SrsBufferCache* c); - virtual int write_audio(int64_t timestamp, char* data, int size); - virtual int write_video(int64_t timestamp, char* data, int size); - virtual int write_metadata(int64_t timestamp, char* data, int size); + virtual srs_error_t initialize(SrsFileWriter* w, SrsBufferCache* c); + virtual srs_error_t write_audio(int64_t timestamp, char* data, int size); + virtual srs_error_t write_video(int64_t timestamp, char* data, int size); + virtual srs_error_t write_metadata(int64_t timestamp, char* data, int size); public: virtual bool has_cache(); - virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter); + virtual srs_error_t dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter); }; /** @@ -204,14 +204,14 @@ public: SrsBufferWriter(ISrsHttpResponseWriter* w); virtual ~SrsBufferWriter(); public: - virtual int open(std::string file); + virtual srs_error_t open(std::string file); virtual void close(); public: virtual bool is_open(); virtual int64_t tellg(); public: - virtual int write(void* buf, size_t count, ssize_t* pnwrite); - virtual int writev(const iovec* iov, int iovcnt, ssize_t* pnwrite); + virtual srs_error_t write(void* buf, size_t count, ssize_t* pnwrite); + virtual srs_error_t writev(const iovec* iov, int iovcnt, ssize_t* pnwrite); }; /** @@ -227,11 +227,11 @@ private: public: SrsLiveStream(SrsSource* s, SrsRequest* r, SrsBufferCache* c); virtual ~SrsLiveStream(); - virtual int update(SrsSource* s, SrsRequest* r); + virtual srs_error_t update(SrsSource* s, SrsRequest* r); public: virtual srs_error_t serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r); private: - virtual int streaming_send_messages(ISrsBufferEncoder* enc, SrsSharedPtrMessage** msgs, int nb_msgs); + virtual srs_error_t streaming_send_messages(ISrsBufferEncoder* enc, SrsSharedPtrMessage** msgs, int nb_msgs); }; /** @@ -286,7 +286,7 @@ public: virtual srs_error_t initialize(); // http flv/ts/mp3/aac stream public: - virtual int http_mount(SrsSource* s, SrsRequest* r); + virtual srs_error_t http_mount(SrsSource* s, SrsRequest* r); virtual void http_unmount(SrsSource* s, SrsRequest* r); // interface ISrsReloadHandler. public: @@ -296,8 +296,8 @@ public: public: virtual srs_error_t hijack(ISrsHttpMessage* request, ISrsHttpHandler** ph); private: - virtual int initialize_flv_streaming(); - virtual int initialize_flv_entry(std::string vhost); + virtual srs_error_t initialize_flv_streaming(); + virtual srs_error_t initialize_flv_entry(std::string vhost); }; #endif diff --git a/trunk/src/kernel/srs_kernel_aac.cpp b/trunk/src/kernel/srs_kernel_aac.cpp index 2ec227afd..dffcabad9 100644 --- a/trunk/src/kernel/srs_kernel_aac.cpp +++ b/trunk/src/kernel/srs_kernel_aac.cpp @@ -39,55 +39,48 @@ using namespace std; #include #include #include +#include SrsAacTransmuxer::SrsAacTransmuxer() { _fs = NULL; got_sequence_header = false; - tag_stream = new SrsBuffer(); aac_object = SrsAacObjectTypeReserved; } SrsAacTransmuxer::~SrsAacTransmuxer() { - srs_freep(tag_stream); } -int SrsAacTransmuxer::initialize(SrsFileWriter* fs) +srs_error_t SrsAacTransmuxer::initialize(SrsFileWriter* fs) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(fs); if (!fs->is_open()) { - ret = ERROR_KERNEL_AAC_STREAM_CLOSED; - srs_warn("stream is not open for encoder. ret=%d", ret); - return ret; + return srs_error_new(ERROR_KERNEL_AAC_STREAM_CLOSED, "stream is not open"); } _fs = fs; - return ret; + return err; } -int SrsAacTransmuxer::write_audio(int64_t timestamp, char* data, int size) +srs_error_t SrsAacTransmuxer::write_audio(int64_t timestamp, char* data, int size) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(data); timestamp &= 0x7fffffff; - SrsBuffer* stream = tag_stream; - if ((ret = stream->initialize(data, size)) != ERROR_SUCCESS) { - return ret; - } + SrsBuffer* stream = new SrsBuffer(data, size); + SrsAutoFree(SrsBuffer, stream); // audio decode if (!stream->require(1)) { - ret = ERROR_AAC_DECODE_ERROR; - srs_error("aac decode audio sound_format failed. ret=%d", ret); - return ret; + return srs_error_new(ERROR_AAC_DECODE_ERROR, "aac decode audio sound_format failed"); } // @see: E.4.2 Audio Tags, video_file_format_spec_v10_1.pdf, page 76 @@ -99,15 +92,11 @@ int SrsAacTransmuxer::write_audio(int64_t timestamp, char* data, int size) sound_format = (sound_format >> 4) & 0x0f; if ((SrsAudioCodecId)sound_format != SrsAudioCodecIdAAC) { - ret = ERROR_AAC_DECODE_ERROR; - srs_error("aac required, format=%d. ret=%d", sound_format, ret); - return ret; + return srs_error_new(ERROR_AAC_DECODE_ERROR, "aac required, format=%d", sound_format); } if (!stream->require(1)) { - ret = ERROR_AAC_DECODE_ERROR; - srs_error("aac decode aac_packet_type failed. ret=%d", ret); - return ret; + return srs_error_new(ERROR_AAC_DECODE_ERROR, "aac decode aac_packet_type failed"); } SrsAudioAacFrameTrait aac_packet_type = (SrsAudioAacFrameTrait)stream->read_1bytes(); @@ -120,9 +109,7 @@ int SrsAacTransmuxer::write_audio(int64_t timestamp, char* data, int size) // samplingFrequencyIndex, aac_sample_rate, 4bits. // channelConfiguration, aac_channels, 4bits if (!stream->require(2)) { - ret = ERROR_AAC_DECODE_ERROR; - srs_error("aac decode sequence header failed. ret=%d", ret); - return ret; + return srs_error_new(ERROR_AAC_DECODE_ERROR, "aac decode sequence header failed"); } int8_t audioObjectType = stream->read_1bytes(); @@ -136,13 +123,11 @@ int SrsAacTransmuxer::write_audio(int64_t timestamp, char* data, int size) got_sequence_header = true; - return ret; + return err; } if (!got_sequence_header) { - ret = ERROR_AAC_DECODE_ERROR; - srs_error("aac no sequence header. ret=%d", ret); - return ret; + return srs_error_new(ERROR_AAC_DECODE_ERROR, "aac no sequence header"); } // the left is the aac raw frame data. @@ -207,16 +192,16 @@ int SrsAacTransmuxer::write_audio(int64_t timestamp, char* data, int size) } // write 7bytes fixed header. - if ((ret = _fs->write(aac_fixed_header, 7, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = _fs->write(aac_fixed_header, 7, NULL)) != srs_success) { + return srs_error_wrap(err, "write aac header"); } // write aac frame body. - if ((ret = _fs->write(data + stream->pos(), aac_raw_length, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = _fs->write(data + stream->pos(), aac_raw_length, NULL)) != srs_success) { + return srs_error_wrap(err, "write aac frame"); } - return ret; + return err; } #endif diff --git a/trunk/src/kernel/srs_kernel_aac.hpp b/trunk/src/kernel/srs_kernel_aac.hpp index 897ae3b21..8cbe01328 100644 --- a/trunk/src/kernel/srs_kernel_aac.hpp +++ b/trunk/src/kernel/srs_kernel_aac.hpp @@ -48,8 +48,6 @@ private: int8_t aac_sample_rate; int8_t aac_channels; bool got_sequence_header; -private: - SrsBuffer* tag_stream; public: SrsAacTransmuxer(); virtual ~SrsAacTransmuxer(); @@ -59,13 +57,13 @@ public: * @remark user can initialize multiple times to encode multiple aac files. * @remark, user must free the fs, aac encoder never close/free it. */ - virtual int initialize(SrsFileWriter* fs); + virtual srs_error_t initialize(SrsFileWriter* fs); public: /** * write audio/video packet. * @remark assert data is not NULL. */ - virtual int write_audio(int64_t timestamp, char* data, int size); + virtual srs_error_t write_audio(int64_t timestamp, char* data, int size); }; #endif diff --git a/trunk/src/kernel/srs_kernel_buffer.cpp b/trunk/src/kernel/srs_kernel_buffer.cpp index e7bc8a839..361b9bcad 100644 --- a/trunk/src/kernel/srs_kernel_buffer.cpp +++ b/trunk/src/kernel/srs_kernel_buffer.cpp @@ -39,19 +39,14 @@ ISrsCodec::~ISrsCodec() SrsBuffer::SrsBuffer() { - set_value(NULL, 0); + p = bytes = NULL; + nb_bytes = 0; + + // TODO: support both little and big endian. + srs_assert(srs_is_little_endian()); } SrsBuffer::SrsBuffer(char* b, int nb_b) -{ - set_value(b, nb_b); -} - -SrsBuffer::~SrsBuffer() -{ -} - -void SrsBuffer::set_value(char* b, int nb_b) { p = bytes = b; nb_bytes = nb_b; @@ -60,27 +55,8 @@ void SrsBuffer::set_value(char* b, int nb_b) srs_assert(srs_is_little_endian()); } -int SrsBuffer::initialize(char* b, int nb) +SrsBuffer::~SrsBuffer() { - int ret = ERROR_SUCCESS; - - if (!b) { - ret = ERROR_KERNEL_STREAM_INIT; - srs_error("stream param bytes must not be NULL. ret=%d", ret); - return ret; - } - - if (nb <= 0) { - ret = ERROR_KERNEL_STREAM_INIT; - srs_error("stream param size must be positive. ret=%d", ret); - return ret; - } - - nb_bytes = nb; - p = bytes = b; - srs_info("init stream ok, size=%d", size()); - - return ret; } char* SrsBuffer::data() @@ -98,6 +74,11 @@ int SrsBuffer::pos() return (int)(p - bytes); } +int SrsBuffer::left() +{ + return nb_bytes - (int)(p - bytes); +} + bool SrsBuffer::empty() { return !bytes || (p >= bytes + nb_bytes); @@ -281,11 +262,11 @@ SrsBitBuffer::~SrsBitBuffer() { } -int SrsBitBuffer::initialize(SrsBuffer* s) { +srs_error_t SrsBitBuffer::initialize(SrsBuffer* s) { stream = s; cb = 0; cb_left = 0; - return ERROR_SUCCESS; + return srs_success; } bool SrsBitBuffer::empty() { diff --git a/trunk/src/kernel/srs_kernel_buffer.hpp b/trunk/src/kernel/srs_kernel_buffer.hpp index 3a9ae263e..5cc006c4e 100644 --- a/trunk/src/kernel/srs_kernel_buffer.hpp +++ b/trunk/src/kernel/srs_kernel_buffer.hpp @@ -70,12 +70,12 @@ public: /** * encode object to bytes in SrsBuffer. */ - virtual int encode(SrsBuffer* buf) = 0; + virtual srs_error_t encode(SrsBuffer* buf) = 0; public: /** * decode object from bytes in SrsBuffer. */ - virtual int decode(SrsBuffer* buf) = 0; + virtual srs_error_t decode(SrsBuffer* buf) = 0; }; /** @@ -97,19 +97,7 @@ public: SrsBuffer(); SrsBuffer(char* b, int nb_b); virtual ~SrsBuffer(); -private: - virtual void set_value(char* b, int nb_b); -public: - /** - * initialize the stream from bytes. - * @b, the bytes to convert from/to basic types. - * @nb, the size of bytes, total number of bytes for stream. - * @remark, stream never free the bytes, user must free it. - * @remark, return error when bytes NULL. - * @remark, return error when size is not positive. - */ - virtual int initialize(char* b, int nb); - // get the status of stream +// get the status of stream public: /** * get data of stream, set by initialize. @@ -125,6 +113,8 @@ public: * tell the current pos. */ virtual int pos(); + // Left bytes in buffer, total size() minus the current pos(). + virtual int left(); /** * whether stream is empty. * if empty, user should never read or write. @@ -219,7 +209,7 @@ public: SrsBitBuffer(); virtual ~SrsBitBuffer(); public: - virtual int initialize(SrsBuffer* s); + virtual srs_error_t initialize(SrsBuffer* s); virtual bool empty(); virtual int8_t read_bit(); }; diff --git a/trunk/src/kernel/srs_kernel_codec.cpp b/trunk/src/kernel/srs_kernel_codec.cpp index fe43cd63b..ed4b797b9 100644 --- a/trunk/src/kernel/srs_kernel_codec.cpp +++ b/trunk/src/kernel/srs_kernel_codec.cpp @@ -507,7 +507,6 @@ SrsFormat::SrsFormat() vcodec = NULL; audio = NULL; video = NULL; - buffer = new SrsBuffer(); avc_parse_sps = true; raw = NULL; nb_raw = 0; @@ -519,7 +518,6 @@ SrsFormat::~SrsFormat() srs_freep(video); srs_freep(acodec); srs_freep(vcodec); - srs_freep(buffer); } srs_error_t SrsFormat::initialize() @@ -529,7 +527,6 @@ srs_error_t SrsFormat::initialize() srs_error_t SrsFormat::on_audio(int64_t timestamp, char* data, int size) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; if (!data || size <= 0) { @@ -537,9 +534,8 @@ srs_error_t SrsFormat::on_audio(int64_t timestamp, char* data, int size) return err; } - if ((ret = buffer->initialize(data, size)) != ERROR_SUCCESS) { - return srs_error_new(ret, "init buffer"); - } + SrsBuffer* buffer = new SrsBuffer(data, size); + SrsAutoFree(SrsBuffer, buffer); // audio decode if (!buffer->require(1)) { @@ -577,7 +573,6 @@ srs_error_t SrsFormat::on_audio(int64_t timestamp, char* data, int size) srs_error_t SrsFormat::on_video(int64_t timestamp, char* data, int size) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; if (!data || size <= 0) { @@ -585,9 +580,8 @@ srs_error_t SrsFormat::on_video(int64_t timestamp, char* data, int size) return err; } - if ((ret = buffer->initialize(data, size)) != ERROR_SUCCESS) { - return srs_error_new(ret, "init buffer"); - } + SrsBuffer* buffer = new SrsBuffer(data, size); + SrsAutoFree(SrsBuffer, buffer); // video decode if (!buffer->require(1)) { @@ -785,19 +779,16 @@ srs_error_t SrsFormat::avc_demux_sps_pps(SrsBuffer* stream) srs_error_t SrsFormat::avc_demux_sps() { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; if (vcodec->sequenceParameterSetNALUnit.empty()) { return err; } - SrsBuffer stream; char* sps = &vcodec->sequenceParameterSetNALUnit[0]; int nbsps = (int)vcodec->sequenceParameterSetNALUnit.size(); - if ((ret = stream.initialize(sps, nbsps)) != ERROR_SUCCESS) { - return srs_error_new(ret, "init stream"); - } + + SrsBuffer stream(sps, nbsps); // for NALU, 7.3.1 NAL unit syntax // ISO_IEC_14496-10-AVC-2012.pdf, page 61. @@ -856,7 +847,6 @@ srs_error_t SrsFormat::avc_demux_sps() srs_error_t SrsFormat::avc_demux_sps_rbsp(char* rbsp, int nb_rbsp) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; // we donot parse the detail of sps. @@ -866,10 +856,7 @@ srs_error_t SrsFormat::avc_demux_sps_rbsp(char* rbsp, int nb_rbsp) } // reparse the rbsp. - SrsBuffer stream; - if ((ret = stream.initialize(rbsp, nb_rbsp)) != ERROR_SUCCESS) { - return srs_error_new(ret, "init stream"); - } + SrsBuffer stream(rbsp, nb_rbsp); // for SPS, 7.3.2.1.1 Sequence parameter set data syntax // ISO_IEC_14496-10-AVC-2012.pdf, page 62. @@ -892,13 +879,13 @@ srs_error_t SrsFormat::avc_demux_sps_rbsp(char* rbsp, int nb_rbsp) } SrsBitBuffer bs; - if ((ret = bs.initialize(&stream)) != ERROR_SUCCESS) { - return srs_error_new(ret, "init bit buffer"); + if ((err = bs.initialize(&stream)) != srs_success) { + return srs_error_wrap(err, "init bit buffer"); } int32_t seq_parameter_set_id = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, seq_parameter_set_id)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read seq_parameter_set_id"); + if ((err = srs_avc_nalu_read_uev(&bs, seq_parameter_set_id)) != srs_success) { + return srs_error_wrap(err, "read seq_parameter_set_id"); } if (seq_parameter_set_id < 0) { return srs_error_new(ERROR_HLS_DECODE_ERROR, "sps the seq_parameter_set_id invalid"); @@ -908,110 +895,110 @@ srs_error_t SrsFormat::avc_demux_sps_rbsp(char* rbsp, int nb_rbsp) if (profile_idc == 100 || profile_idc == 110 || profile_idc == 122 || profile_idc == 244 || profile_idc == 44 || profile_idc == 83 || profile_idc == 86 || profile_idc == 118 || profile_idc == 128) { - if ((ret = srs_avc_nalu_read_uev(&bs, chroma_format_idc)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read chroma_format_idc"); + if ((err = srs_avc_nalu_read_uev(&bs, chroma_format_idc)) != srs_success) { + return srs_error_wrap(err, "read chroma_format_idc"); } if (chroma_format_idc == 3) { int8_t separate_colour_plane_flag = -1; - if ((ret = srs_avc_nalu_read_bit(&bs, separate_colour_plane_flag)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read separate_colour_plane_flag"); + if ((err = srs_avc_nalu_read_bit(&bs, separate_colour_plane_flag)) != srs_success) { + return srs_error_wrap(err, "read separate_colour_plane_flag"); } } int32_t bit_depth_luma_minus8 = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, bit_depth_luma_minus8)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read bit_depth_luma_minus8");; + if ((err = srs_avc_nalu_read_uev(&bs, bit_depth_luma_minus8)) != srs_success) { + return srs_error_wrap(err, "read bit_depth_luma_minus8");; } int32_t bit_depth_chroma_minus8 = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, bit_depth_chroma_minus8)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read bit_depth_chroma_minus8");; + if ((err = srs_avc_nalu_read_uev(&bs, bit_depth_chroma_minus8)) != srs_success) { + return srs_error_wrap(err, "read bit_depth_chroma_minus8");; } int8_t qpprime_y_zero_transform_bypass_flag = -1; - if ((ret = srs_avc_nalu_read_bit(&bs, qpprime_y_zero_transform_bypass_flag)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read qpprime_y_zero_transform_bypass_flag");; + if ((err = srs_avc_nalu_read_bit(&bs, qpprime_y_zero_transform_bypass_flag)) != srs_success) { + return srs_error_wrap(err, "read qpprime_y_zero_transform_bypass_flag");; } int8_t seq_scaling_matrix_present_flag = -1; - if ((ret = srs_avc_nalu_read_bit(&bs, seq_scaling_matrix_present_flag)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read seq_scaling_matrix_present_flag");; + if ((err = srs_avc_nalu_read_bit(&bs, seq_scaling_matrix_present_flag)) != srs_success) { + return srs_error_wrap(err, "read seq_scaling_matrix_present_flag");; } if (seq_scaling_matrix_present_flag) { int nb_scmpfs = ((chroma_format_idc != 3)? 8:12); for (int i = 0; i < nb_scmpfs; i++) { int8_t seq_scaling_matrix_present_flag_i = -1; - if ((ret = srs_avc_nalu_read_bit(&bs, seq_scaling_matrix_present_flag_i)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read seq_scaling_matrix_present_flag_i");; + if ((err = srs_avc_nalu_read_bit(&bs, seq_scaling_matrix_present_flag_i)) != srs_success) { + return srs_error_wrap(err, "read seq_scaling_matrix_present_flag_i");; } } } } int32_t log2_max_frame_num_minus4 = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, log2_max_frame_num_minus4)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read log2_max_frame_num_minus4");; + if ((err = srs_avc_nalu_read_uev(&bs, log2_max_frame_num_minus4)) != srs_success) { + return srs_error_wrap(err, "read log2_max_frame_num_minus4");; } int32_t pic_order_cnt_type = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, pic_order_cnt_type)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read pic_order_cnt_type");; + if ((err = srs_avc_nalu_read_uev(&bs, pic_order_cnt_type)) != srs_success) { + return srs_error_wrap(err, "read pic_order_cnt_type");; } if (pic_order_cnt_type == 0) { int32_t log2_max_pic_order_cnt_lsb_minus4 = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, log2_max_pic_order_cnt_lsb_minus4)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read log2_max_pic_order_cnt_lsb_minus4");; + if ((err = srs_avc_nalu_read_uev(&bs, log2_max_pic_order_cnt_lsb_minus4)) != srs_success) { + return srs_error_wrap(err, "read log2_max_pic_order_cnt_lsb_minus4");; } } else if (pic_order_cnt_type == 1) { int8_t delta_pic_order_always_zero_flag = -1; - if ((ret = srs_avc_nalu_read_bit(&bs, delta_pic_order_always_zero_flag)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read delta_pic_order_always_zero_flag");; + if ((err = srs_avc_nalu_read_bit(&bs, delta_pic_order_always_zero_flag)) != srs_success) { + return srs_error_wrap(err, "read delta_pic_order_always_zero_flag");; } int32_t offset_for_non_ref_pic = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, offset_for_non_ref_pic)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read offset_for_non_ref_pic");; + if ((err = srs_avc_nalu_read_uev(&bs, offset_for_non_ref_pic)) != srs_success) { + return srs_error_wrap(err, "read offset_for_non_ref_pic");; } int32_t offset_for_top_to_bottom_field = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, offset_for_top_to_bottom_field)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read offset_for_top_to_bottom_field");; + if ((err = srs_avc_nalu_read_uev(&bs, offset_for_top_to_bottom_field)) != srs_success) { + return srs_error_wrap(err, "read offset_for_top_to_bottom_field");; } int32_t num_ref_frames_in_pic_order_cnt_cycle = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, num_ref_frames_in_pic_order_cnt_cycle)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read num_ref_frames_in_pic_order_cnt_cycle");; + if ((err = srs_avc_nalu_read_uev(&bs, num_ref_frames_in_pic_order_cnt_cycle)) != srs_success) { + return srs_error_wrap(err, "read num_ref_frames_in_pic_order_cnt_cycle");; } if (num_ref_frames_in_pic_order_cnt_cycle < 0) { return srs_error_new(ERROR_HLS_DECODE_ERROR, "sps the num_ref_frames_in_pic_order_cnt_cycle"); } for (int i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++) { int32_t offset_for_ref_frame_i = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, offset_for_ref_frame_i)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read offset_for_ref_frame_i");; + if ((err = srs_avc_nalu_read_uev(&bs, offset_for_ref_frame_i)) != srs_success) { + return srs_error_wrap(err, "read offset_for_ref_frame_i");; } } } int32_t max_num_ref_frames = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, max_num_ref_frames)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read max_num_ref_frames");; + if ((err = srs_avc_nalu_read_uev(&bs, max_num_ref_frames)) != srs_success) { + return srs_error_wrap(err, "read max_num_ref_frames");; } int8_t gaps_in_frame_num_value_allowed_flag = -1; - if ((ret = srs_avc_nalu_read_bit(&bs, gaps_in_frame_num_value_allowed_flag)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read gaps_in_frame_num_value_allowed_flag");; + if ((err = srs_avc_nalu_read_bit(&bs, gaps_in_frame_num_value_allowed_flag)) != srs_success) { + return srs_error_wrap(err, "read gaps_in_frame_num_value_allowed_flag");; } int32_t pic_width_in_mbs_minus1 = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, pic_width_in_mbs_minus1)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read pic_width_in_mbs_minus1");; + if ((err = srs_avc_nalu_read_uev(&bs, pic_width_in_mbs_minus1)) != srs_success) { + return srs_error_wrap(err, "read pic_width_in_mbs_minus1");; } int32_t pic_height_in_map_units_minus1 = -1; - if ((ret = srs_avc_nalu_read_uev(&bs, pic_height_in_map_units_minus1)) != ERROR_SUCCESS) { - return srs_error_new(ret, "read pic_height_in_map_units_minus1");; + if ((err = srs_avc_nalu_read_uev(&bs, pic_height_in_map_units_minus1)) != srs_success) { + return srs_error_wrap(err, "read pic_height_in_map_units_minus1");; } vcodec->width = (int)(pic_width_in_mbs_minus1 + 1) * 16; @@ -1323,12 +1310,10 @@ srs_error_t SrsFormat::audio_mp3_demux(SrsBuffer* stream, int64_t timestamp) srs_error_t SrsFormat::audio_aac_sequence_header_demux(char* data, int size) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; - if ((ret = buffer->initialize(data, size)) != ERROR_SUCCESS) { - return srs_error_new(ret, "init buffer"); - } + SrsBuffer* buffer = new SrsBuffer(data, size); + SrsAutoFree(SrsBuffer, buffer); // only need to decode the first 2bytes: // audioObjectType, aac_profile, 5bits. diff --git a/trunk/src/kernel/srs_kernel_codec.hpp b/trunk/src/kernel/srs_kernel_codec.hpp index 50c2a469f..54cc6138c 100644 --- a/trunk/src/kernel/srs_kernel_codec.hpp +++ b/trunk/src/kernel/srs_kernel_codec.hpp @@ -682,8 +682,6 @@ public: public: char* raw; int nb_raw; -private: - SrsBuffer* buffer; public: // for sequence header, whether parse the h.264 sps. // TODO: FIXME: Refine it. diff --git a/trunk/src/kernel/srs_kernel_file.cpp b/trunk/src/kernel/srs_kernel_file.cpp index 4cbe502cd..b3955f100 100644 --- a/trunk/src/kernel/srs_kernel_file.cpp +++ b/trunk/src/kernel/srs_kernel_file.cpp @@ -46,66 +46,54 @@ SrsFileWriter::~SrsFileWriter() close(); } -int SrsFileWriter::open(string p) +srs_error_t SrsFileWriter::open(string p) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (fd > 0) { - ret = ERROR_SYSTEM_FILE_ALREADY_OPENED; - srs_error("file %s already opened. ret=%d", path.c_str(), ret); - return ret; + return srs_error_new(ERROR_SYSTEM_FILE_ALREADY_OPENED, "file %s already opened", p.c_str()); } int flags = O_CREAT|O_WRONLY|O_TRUNC; mode_t mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH; if ((fd = ::open(p.c_str(), flags, mode)) < 0) { - ret = ERROR_SYSTEM_FILE_OPENE; - srs_error("open file %s failed. ret=%d", p.c_str(), ret); - return ret; + return srs_error_new(ERROR_SYSTEM_FILE_OPENE, "open file %s failed", p.c_str()); } path = p; - return ret; + return err; } -int SrsFileWriter::open_append(string p) +srs_error_t SrsFileWriter::open_append(string p) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (fd > 0) { - ret = ERROR_SYSTEM_FILE_ALREADY_OPENED; - srs_error("file %s already opened. ret=%d", path.c_str(), ret); - return ret; + return srs_error_new(ERROR_SYSTEM_FILE_ALREADY_OPENED, "file %s already opened", path.c_str()); } int flags = O_APPEND|O_WRONLY; mode_t mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH; if ((fd = ::open(p.c_str(), flags, mode)) < 0) { - ret = ERROR_SYSTEM_FILE_OPENE; - srs_error("open file %s failed. ret=%d", p.c_str(), ret); - return ret; + return srs_error_new(ERROR_SYSTEM_FILE_OPENE, "open file %s failed", p.c_str()); } path = p; - return ret; + return err; } void SrsFileWriter::close() { - int ret = ERROR_SUCCESS; - if (fd < 0) { return; } if (::close(fd) < 0) { - ret = ERROR_SYSTEM_FILE_CLOSE; - srs_error("close file %s failed. ret=%d", path.c_str(), ret); - return; + srs_warn("close file %s failed", path.c_str()); } fd = -1; @@ -128,35 +116,33 @@ int64_t SrsFileWriter::tellg() return (int64_t)::lseek(fd, 0, SEEK_CUR); } -int SrsFileWriter::write(void* buf, size_t count, ssize_t* pnwrite) +srs_error_t SrsFileWriter::write(void* buf, size_t count, ssize_t* pnwrite) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; ssize_t nwrite; // TODO: FIXME: use st_write. if ((nwrite = ::write(fd, buf, count)) < 0) { - ret = ERROR_SYSTEM_FILE_WRITE; - srs_error("write to file %s failed. ret=%d", path.c_str(), ret); - return ret; + return srs_error_new(ERROR_SYSTEM_FILE_WRITE, "write to file %s failed", path.c_str()); } if (pnwrite != NULL) { *pnwrite = nwrite; } - return ret; + return err; } -int SrsFileWriter::writev(const iovec* iov, int iovcnt, ssize_t* pnwrite) +srs_error_t SrsFileWriter::writev(const iovec* iov, int iovcnt, ssize_t* pnwrite) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; ssize_t nwrite = 0; for (int i = 0; i < iovcnt; i++) { const iovec* piov = iov + i; ssize_t this_nwrite = 0; - if ((ret = write(piov->iov_base, piov->iov_len, &this_nwrite)) != ERROR_SUCCESS) { - return ret; + if ((err = write(piov->iov_base, piov->iov_len, &this_nwrite)) != srs_success) { + return srs_error_wrap(err, "write file"); } nwrite += this_nwrite; } @@ -165,20 +151,21 @@ int SrsFileWriter::writev(const iovec* iov, int iovcnt, ssize_t* pnwrite) *pnwrite = nwrite; } - return ret; + return err; } -int SrsFileWriter::lseek(off_t offset, int whence, off_t* seeked) +srs_error_t SrsFileWriter::lseek(off_t offset, int whence, off_t* seeked) { off_t sk = ::lseek(fd, offset, whence); if (sk < 0) { - return ERROR_SYSTEM_FILE_SEEK; + return srs_error_new(ERROR_SYSTEM_FILE_SEEK, "seek file"); } if (seeked) { *seeked = sk; } - return ERROR_SUCCESS; + + return srs_success; } SrsFileReader::SrsFileReader() @@ -191,25 +178,21 @@ SrsFileReader::~SrsFileReader() close(); } -int SrsFileReader::open(string p) +srs_error_t SrsFileReader::open(string p) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (fd > 0) { - ret = ERROR_SYSTEM_FILE_ALREADY_OPENED; - srs_error("file %s already opened. ret=%d", path.c_str(), ret); - return ret; + return srs_error_new(ERROR_SYSTEM_FILE_ALREADY_OPENED, "file %s already opened", path.c_str()); } if ((fd = ::open(p.c_str(), O_RDONLY)) < 0) { - ret = ERROR_SYSTEM_FILE_OPENE; - srs_error("open file %s failed. ret=%d", p.c_str(), ret); - return ret; + return srs_error_new(ERROR_SYSTEM_FILE_OPENE, "open file %s failed", p.c_str()); } path = p; - return ret; + return err; } void SrsFileReader::close() @@ -262,40 +245,38 @@ int64_t SrsFileReader::filesize() return size; } -int SrsFileReader::read(void* buf, size_t count, ssize_t* pnread) +srs_error_t SrsFileReader::read(void* buf, size_t count, ssize_t* pnread) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; ssize_t nread; // TODO: FIXME: use st_read. if ((nread = ::read(fd, buf, count)) < 0) { - ret = ERROR_SYSTEM_FILE_READ; - srs_error("read from file %s failed. ret=%d", path.c_str(), ret); - return ret; + return srs_error_new(ERROR_SYSTEM_FILE_READ, "read from file %s failed", path.c_str()); } if (nread == 0) { - ret = ERROR_SYSTEM_FILE_EOF; - return ret; + return srs_error_new(ERROR_SYSTEM_FILE_EOF, "file EOF"); } if (pnread != NULL) { *pnread = nread; } - return ret; + return err; } -int SrsFileReader::lseek(off_t offset, int whence, off_t* seeked) +srs_error_t SrsFileReader::lseek(off_t offset, int whence, off_t* seeked) { off_t sk = ::lseek(fd, offset, whence); if (sk < 0) { - return ERROR_SYSTEM_FILE_SEEK; + return srs_error_new(ERROR_SYSTEM_FILE_SEEK, "seek %v failed", (int)sk); } if (seeked) { *seeked = sk; } - return ERROR_SUCCESS; + + return srs_success; } diff --git a/trunk/src/kernel/srs_kernel_file.hpp b/trunk/src/kernel/srs_kernel_file.hpp index c54186478..743cac64d 100644 --- a/trunk/src/kernel/srs_kernel_file.hpp +++ b/trunk/src/kernel/srs_kernel_file.hpp @@ -51,12 +51,12 @@ public: * open file writer, in truncate mode. * @param p a string indicates the path of file to open. */ - virtual int open(std::string p); + virtual srs_error_t open(std::string p); /** * open file writer, in append mode. * @param p a string indicates the path of file to open. */ - virtual int open_append(std::string p); + virtual srs_error_t open_append(std::string p); /** * close current writer. * @remark user can reopen again. @@ -68,9 +68,9 @@ public: virtual int64_t tellg(); // Interface ISrsWriteSeeker public: - virtual int write(void* buf, size_t count, ssize_t* pnwrite); - virtual int writev(const iovec* iov, int iovcnt, ssize_t* pnwrite); - virtual int lseek(off_t offset, int whence, off_t* seeked); + virtual srs_error_t write(void* buf, size_t count, ssize_t* pnwrite); + virtual srs_error_t writev(const iovec* iov, int iovcnt, ssize_t* pnwrite); + virtual srs_error_t lseek(off_t offset, int whence, off_t* seeked); }; /** @@ -89,7 +89,7 @@ public: * open file reader. * @param p a string indicates the path of file to open. */ - virtual int open(std::string p); + virtual srs_error_t open(std::string p); /** * close current reader. * @remark user can reopen again. @@ -104,8 +104,8 @@ public: virtual int64_t filesize(); // Interface ISrsReadSeeker public: - virtual int read(void* buf, size_t count, ssize_t* pnread); - virtual int lseek(off_t offset, int whence, off_t* seeked); + virtual srs_error_t read(void* buf, size_t count, ssize_t* pnread); + virtual srs_error_t lseek(off_t offset, int whence, off_t* seeked); }; #endif diff --git a/trunk/src/kernel/srs_kernel_flv.cpp b/trunk/src/kernel/srs_kernel_flv.cpp index 7cfd4eb23..4a2c72d96 100644 --- a/trunk/src/kernel/srs_kernel_flv.cpp +++ b/trunk/src/kernel/srs_kernel_flv.cpp @@ -39,6 +39,7 @@ using namespace std; #include #include #include +#include SrsMessageHeader::SrsMessageHeader() { @@ -178,10 +179,8 @@ void SrsCommonMessage::create_payload(int size) #endif } -int SrsCommonMessage::create(SrsMessageHeader* pheader, char* body, int size) +srs_error_t SrsCommonMessage::create(SrsMessageHeader* pheader, char* body, int size) { - int ret = ERROR_SUCCESS; - // drop previous payload. srs_freepa(payload); @@ -189,7 +188,7 @@ int SrsCommonMessage::create(SrsMessageHeader* pheader, char* body, int size) this->payload = body; this->size = size; - return ret; + return srs_success; } SrsSharedMessageHeader::SrsSharedMessageHeader() : payload_length(0), message_type(0), perfer_cid(0) @@ -231,12 +230,12 @@ SrsSharedPtrMessage::~SrsSharedPtrMessage() } } -int SrsSharedPtrMessage::create(SrsCommonMessage* msg) +srs_error_t SrsSharedPtrMessage::create(SrsCommonMessage* msg) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = create(&msg->header, msg->payload, msg->size)) != ERROR_SUCCESS) { - return ret; + if ((err = create(&msg->header, msg->payload, msg->size)) != srs_success) { + return srs_error_wrap(err, "create message"); } // to prevent double free of payload: @@ -245,19 +244,16 @@ int SrsSharedPtrMessage::create(SrsCommonMessage* msg) msg->payload = NULL; msg->size = 0; - return ret; + return err; } -int SrsSharedPtrMessage::create(SrsMessageHeader* pheader, char* payload, int size) +srs_error_t SrsSharedPtrMessage::create(SrsMessageHeader* pheader, char* payload, int size) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (ptr) { - ret = ERROR_SYSTEM_ASSERT_FAILED; - srs_error("should not set the payload twice. ret=%d", ret); srs_assert(false); - - return ret; + return srs_error_new(ERROR_SYSTEM_ASSERT_FAILED, "should not set the payload twice"); } ptr = new SrsSharedPtrPayload(); @@ -277,7 +273,7 @@ int SrsSharedPtrMessage::create(SrsMessageHeader* pheader, char* payload, int si this->payload = ptr->payload; this->size = ptr->size; - return ret; + return err; } int SrsSharedPtrMessage::count() @@ -291,8 +287,7 @@ bool SrsSharedPtrMessage::check(int stream_id) // we donot use the complex basic header, // ensure the basic header is 1bytes. if (ptr->header.perfer_cid < 2) { - srs_info("change the chunk_id=%d to default=%d", - ptr->header.perfer_cid, RTMP_CID_ProtocolControl); + srs_info("change the chunk_id=%d to default=%d", ptr->header.perfer_cid, RTMP_CID_ProtocolControl); ptr->header.perfer_cid = RTMP_CID_ProtocolControl; } @@ -324,9 +319,11 @@ bool SrsSharedPtrMessage::is_video() int SrsSharedPtrMessage::chunk_header(char* cache, int nb_cache, bool c0) { if (c0) { - return srs_chunk_header_c0(ptr->header.perfer_cid, timestamp, ptr->header.payload_length, ptr->header.message_type, stream_id, cache, nb_cache); + return srs_chunk_header_c0(ptr->header.perfer_cid, (uint32_t)timestamp, + ptr->header.payload_length, ptr->header.message_type, stream_id, cache, nb_cache); } else { - return srs_chunk_header_c3(ptr->header.perfer_cid, timestamp, cache, nb_cache); + return srs_chunk_header_c3(ptr->header.perfer_cid, (uint32_t)timestamp, + cache, nb_cache); } } @@ -350,7 +347,6 @@ SrsSharedPtrMessage* SrsSharedPtrMessage::copy() SrsFlvTransmuxer::SrsFlvTransmuxer() { writer = NULL; - tag_stream = new SrsBuffer(); #ifdef SRS_PERF_FAST_FLV_ENCODER nb_tag_headers = 0; @@ -364,8 +360,6 @@ SrsFlvTransmuxer::SrsFlvTransmuxer() SrsFlvTransmuxer::~SrsFlvTransmuxer() { - srs_freep(tag_stream); - #ifdef SRS_PERF_FAST_FLV_ENCODER srs_freepa(tag_headers); srs_freepa(iovss_cache); @@ -373,16 +367,16 @@ SrsFlvTransmuxer::~SrsFlvTransmuxer() #endif } -int SrsFlvTransmuxer::initialize(ISrsWriter* fw) +srs_error_t SrsFlvTransmuxer::initialize(ISrsWriter* fw) { srs_assert(fw); writer = fw; - return ERROR_SUCCESS; + return srs_success; } -int SrsFlvTransmuxer::write_header() +srs_error_t SrsFlvTransmuxer::write_header() { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; // 9bytes header and 4bytes first previous-tag-size char flv_header[] = { @@ -397,88 +391,80 @@ int SrsFlvTransmuxer::write_header() // so we generally set the audio/video to 0. // write 9bytes header. - if ((ret = write_header(flv_header)) != ERROR_SUCCESS) { - return ret; + if ((err = write_header(flv_header)) != srs_success) { + return srs_error_wrap(err, "write header"); } - return ret; + return err; } -int SrsFlvTransmuxer::write_header(char flv_header[9]) +srs_error_t SrsFlvTransmuxer::write_header(char flv_header[9]) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; // write data. - if ((ret = writer->write(flv_header, 9, NULL)) != ERROR_SUCCESS) { - srs_error("write flv header failed. ret=%d", ret); - return ret; + if ((err = writer->write(flv_header, 9, NULL)) != srs_success) { + return srs_error_wrap(err, "write flv header failed"); } // previous tag size. char pts[] = { (char)0x00, (char)0x00, (char)0x00, (char)0x00 }; - if ((ret = writer->write(pts, 4, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = writer->write(pts, 4, NULL)) != srs_success) { + return srs_error_wrap(err, "write pts"); } - return ret; + return err; } -int SrsFlvTransmuxer::write_metadata(char type, char* data, int size) +srs_error_t SrsFlvTransmuxer::write_metadata(char type, char* data, int size) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(data); - if ((ret = write_metadata_to_cache(type, data, size, tag_header)) != ERROR_SUCCESS) { - return ret; + if ((err = write_metadata_to_cache(type, data, size, tag_header)) != srs_success) { + return srs_error_wrap(err, "cache metadata"); } - if ((ret = write_tag(tag_header, sizeof(tag_header), data, size)) != ERROR_SUCCESS) { - if (!srs_is_client_gracefully_close(ret)) { - srs_error("write flv data tag failed. ret=%d", ret); - } - return ret; + if ((err = write_tag(tag_header, sizeof(tag_header), data, size)) != srs_success) { + return srs_error_wrap(err, "write tag"); } - return ret; + return err; } -int SrsFlvTransmuxer::write_audio(int64_t timestamp, char* data, int size) +srs_error_t SrsFlvTransmuxer::write_audio(int64_t timestamp, char* data, int size) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(data); - if ((ret = write_audio_to_cache(timestamp, data, size, tag_header)) != ERROR_SUCCESS) { - return ret; + if ((err = write_audio_to_cache(timestamp, data, size, tag_header)) != srs_success) { + return srs_error_wrap(err, "cache audio"); } - if ((ret = write_tag(tag_header, sizeof(tag_header), data, size)) != ERROR_SUCCESS) { - if (!srs_is_client_gracefully_close(ret)) { - srs_error("write flv audio tag failed. ret=%d", ret); - } - return ret; + if ((err = write_tag(tag_header, sizeof(tag_header), data, size)) != srs_success) { + return srs_error_wrap(err, "write tag"); } - return ret; + return err; } -int SrsFlvTransmuxer::write_video(int64_t timestamp, char* data, int size) +srs_error_t SrsFlvTransmuxer::write_video(int64_t timestamp, char* data, int size) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(data); - if ((ret = write_video_to_cache(timestamp, data, size, tag_header)) != ERROR_SUCCESS) { - return ret; + if ((err = write_video_to_cache(timestamp, data, size, tag_header)) != srs_success) { + return srs_error_wrap(err, "cache video"); } - if ((ret = write_tag(tag_header, sizeof(tag_header), data, size)) != ERROR_SUCCESS) { - srs_error("write flv video tag failed. ret=%d", ret); - return ret; + if ((err = write_tag(tag_header, sizeof(tag_header), data, size)) != srs_success) { + return srs_error_wrap(err, "write flv video tag failed"); } - return ret; + return err; } int SrsFlvTransmuxer::size_tag(int data_size) @@ -488,9 +474,9 @@ int SrsFlvTransmuxer::size_tag(int data_size) } #ifdef SRS_PERF_FAST_FLV_ENCODER -int SrsFlvTransmuxer::write_tags(SrsSharedPtrMessage** msgs, int count) +srs_error_t SrsFlvTransmuxer::write_tags(SrsSharedPtrMessage** msgs, int count) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; // realloc the iovss. int nb_iovss = 3 * count; @@ -527,22 +513,22 @@ int SrsFlvTransmuxer::write_tags(SrsSharedPtrMessage** msgs, int count) // cache all flv header. if (msg->is_audio()) { - if ((ret = write_audio_to_cache(msg->timestamp, msg->payload, msg->size, cache)) != ERROR_SUCCESS) { - return ret; + if ((err = write_audio_to_cache(msg->timestamp, msg->payload, msg->size, cache)) != srs_success) { + return srs_error_wrap(err, "cache audio"); } } else if (msg->is_video()) { - if ((ret = write_video_to_cache(msg->timestamp, msg->payload, msg->size, cache)) != ERROR_SUCCESS) { - return ret; + if ((err = write_video_to_cache(msg->timestamp, msg->payload, msg->size, cache)) != srs_success) { + return srs_error_wrap(err, "cache video"); } } else { - if ((ret = write_metadata_to_cache(SrsFrameTypeScript, msg->payload, msg->size, cache)) != ERROR_SUCCESS) { - return ret; + if ((err = write_metadata_to_cache(SrsFrameTypeScript, msg->payload, msg->size, cache)) != srs_success) { + return srs_error_wrap(err, "cache metadata"); } } // cache all pts. - if ((ret = write_pts_to_cache(SRS_FLV_TAG_HEADER_SIZE + msg->size, pts)) != ERROR_SUCCESS) { - return ret; + if ((err = write_pts_to_cache(SRS_FLV_TAG_HEADER_SIZE + msg->size, pts)) != srs_success) { + return srs_error_wrap(err, "cache pts"); } // all ioves. @@ -559,20 +545,17 @@ int SrsFlvTransmuxer::write_tags(SrsSharedPtrMessage** msgs, int count) iovs += 3; } - if ((ret = writer->writev(iovss, nb_iovss, NULL)) != ERROR_SUCCESS) { - if (!srs_is_client_gracefully_close(ret)) { - srs_error("write flv tags failed. ret=%d", ret); - } - return ret; + if ((err = writer->writev(iovss, nb_iovss, NULL)) != srs_success) { + return srs_error_wrap(err, "write flv tags failed"); } - return ret; + return err; } #endif -int SrsFlvTransmuxer::write_metadata_to_cache(char type, char* data, int size, char* cache) +srs_error_t SrsFlvTransmuxer::write_metadata_to_cache(char type, char* data, int size, char* cache) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(data); @@ -585,22 +568,22 @@ int SrsFlvTransmuxer::write_metadata_to_cache(char type, char* data, int size, c (char)0x00, (char)0x00, (char)0x00, // StreamID UI24 Always 0. };*/ + SrsBuffer* tag_stream = new SrsBuffer(cache, 11); + SrsAutoFree(SrsBuffer, tag_stream); + // write data size. - if ((ret = tag_stream->initialize(cache, 11)) != ERROR_SUCCESS) { - return ret; - } tag_stream->write_1bytes(type); tag_stream->write_3bytes(size); tag_stream->write_3bytes(0x00); tag_stream->write_1bytes(0x00); tag_stream->write_3bytes(0x00); - return ret; + return err; } -int SrsFlvTransmuxer::write_audio_to_cache(int64_t timestamp, char* data, int size, char* cache) +srs_error_t SrsFlvTransmuxer::write_audio_to_cache(int64_t timestamp, char* data, int size, char* cache) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(data); @@ -615,10 +598,10 @@ int SrsFlvTransmuxer::write_audio_to_cache(int64_t timestamp, char* data, int si (char)0x00, (char)0x00, (char)0x00, // StreamID UI24 Always 0. };*/ + SrsBuffer* tag_stream = new SrsBuffer(cache, 11); + SrsAutoFree(SrsBuffer, tag_stream); + // write data size. - if ((ret = tag_stream->initialize(cache, 11)) != ERROR_SUCCESS) { - return ret; - } tag_stream->write_1bytes(SrsFrameTypeAudio); tag_stream->write_3bytes(size); tag_stream->write_3bytes((int32_t)timestamp); @@ -626,12 +609,12 @@ int SrsFlvTransmuxer::write_audio_to_cache(int64_t timestamp, char* data, int si tag_stream->write_1bytes((timestamp >> 24) & 0xFF); tag_stream->write_3bytes(0x00); - return ret; + return err; } -int SrsFlvTransmuxer::write_video_to_cache(int64_t timestamp, char* data, int size, char* cache) +srs_error_t SrsFlvTransmuxer::write_video_to_cache(int64_t timestamp, char* data, int size, char* cache) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(data); @@ -646,10 +629,10 @@ int SrsFlvTransmuxer::write_video_to_cache(int64_t timestamp, char* data, int si (char)0x00, (char)0x00, (char)0x00, // StreamID UI24 Always 0. };*/ + SrsBuffer* tag_stream = new SrsBuffer(cache, 11); + SrsAutoFree(SrsBuffer, tag_stream); + // write data size. - if ((ret = tag_stream->initialize(cache, 11)) != ERROR_SUCCESS) { - return ret; - } tag_stream->write_1bytes(SrsFrameTypeVideo); tag_stream->write_3bytes(size); tag_stream->write_3bytes((int32_t)timestamp); @@ -657,29 +640,29 @@ int SrsFlvTransmuxer::write_video_to_cache(int64_t timestamp, char* data, int si tag_stream->write_1bytes((timestamp >> 24) & 0xFF); tag_stream->write_3bytes(0x00); - return ret; + return err; } -int SrsFlvTransmuxer::write_pts_to_cache(int size, char* cache) +srs_error_t SrsFlvTransmuxer::write_pts_to_cache(int size, char* cache) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; + + SrsBuffer* tag_stream = new SrsBuffer(cache, 11); + SrsAutoFree(SrsBuffer, tag_stream); - if ((ret = tag_stream->initialize(cache, SRS_FLV_PREVIOUS_TAG_SIZE)) != ERROR_SUCCESS) { - return ret; - } tag_stream->write_4bytes(size); - return ret; + return err; } -int SrsFlvTransmuxer::write_tag(char* header, int header_size, char* tag, int tag_size) +srs_error_t SrsFlvTransmuxer::write_tag(char* header, int header_size, char* tag, int tag_size) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; // PreviousTagSizeN UI32 Size of last tag, including its header, in bytes. char pre_size[SRS_FLV_PREVIOUS_TAG_SIZE]; - if ((ret = write_pts_to_cache(tag_size + header_size, pre_size)) != ERROR_SUCCESS) { - return ret; + if ((err = write_pts_to_cache(tag_size + header_size, pre_size)) != srs_success) { + return srs_error_wrap(err, "cache pts"); } iovec iovs[3]; @@ -690,58 +673,51 @@ int SrsFlvTransmuxer::write_tag(char* header, int header_size, char* tag, int ta iovs[2].iov_base = pre_size; iovs[2].iov_len = SRS_FLV_PREVIOUS_TAG_SIZE; - if ((ret = writer->writev(iovs, 3, NULL)) != ERROR_SUCCESS) { - if (!srs_is_client_gracefully_close(ret)) { - srs_error("write flv tag failed. ret=%d", ret); - } - return ret; + if ((err = writer->writev(iovs, 3, NULL)) != srs_success) { + return srs_error_wrap(err, "write flv tag failed"); } - return ret; + return err; } SrsFlvDecoder::SrsFlvDecoder() { reader = NULL; - tag_stream = new SrsBuffer(); } SrsFlvDecoder::~SrsFlvDecoder() { - srs_freep(tag_stream); } -int SrsFlvDecoder::initialize(ISrsReader* fr) +srs_error_t SrsFlvDecoder::initialize(ISrsReader* fr) { srs_assert(fr); reader = fr; - return ERROR_SUCCESS; + return srs_success; } -int SrsFlvDecoder::read_header(char header[9]) +srs_error_t SrsFlvDecoder::read_header(char header[9]) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(header); // TODO: FIXME: Should use readfully. - if ((ret = reader->read(header, 9, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = reader->read(header, 9, NULL)) != srs_success) { + return srs_error_wrap(err, "read header"); } char* h = header; if (h[0] != 'F' || h[1] != 'L' || h[2] != 'V') { - ret = ERROR_KERNEL_FLV_HEADER; - srs_warn("flv header must start with FLV. ret=%d", ret); - return ret; + return srs_error_new(ERROR_KERNEL_FLV_HEADER, "flv header must start with FLV"); } - return ret; + return err; } -int SrsFlvDecoder::read_tag_header(char* ptype, int32_t* pdata_size, uint32_t* ptime) +srs_error_t SrsFlvDecoder::read_tag_header(char* ptype, int32_t* pdata_size, uint32_t* ptime) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(ptype); srs_assert(pdata_size); @@ -751,11 +727,8 @@ int SrsFlvDecoder::read_tag_header(char* ptype, int32_t* pdata_size, uint32_t* p // read tag header // TODO: FIXME: Should use readfully. - if ((ret = reader->read(th, 11, NULL)) != ERROR_SUCCESS) { - if (ret != ERROR_SYSTEM_FILE_EOF) { - srs_error("read flv tag header failed. ret=%d", ret); - } - return ret; + if ((err = reader->read(th, 11, NULL)) != srs_success) { + return srs_error_wrap(err, "read flv tag header failed"); } // Reserved UB [2] @@ -779,80 +752,68 @@ int SrsFlvDecoder::read_tag_header(char* ptype, int32_t* pdata_size, uint32_t* p // TimestampExtended UI8 pp[3] = th[7]; - return ret; + return err; } -int SrsFlvDecoder::read_tag_data(char* data, int32_t size) +srs_error_t SrsFlvDecoder::read_tag_data(char* data, int32_t size) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(data); // TODO: FIXME: Should use readfully. - if ((ret = reader->read(data, size, NULL)) != ERROR_SUCCESS) { - if (ret != ERROR_SYSTEM_FILE_EOF) { - srs_error("read flv tag header failed. ret=%d", ret); - } - return ret; + if ((err = reader->read(data, size, NULL)) != srs_success) { + return srs_error_wrap(err, "read flv tag header failed"); } - return ret; + return err; } -int SrsFlvDecoder::read_previous_tag_size(char previous_tag_size[4]) +srs_error_t SrsFlvDecoder::read_previous_tag_size(char previous_tag_size[4]) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(previous_tag_size); // ignore 4bytes tag size. // TODO: FIXME: Should use readfully. - if ((ret = reader->read(previous_tag_size, 4, NULL)) != ERROR_SUCCESS) { - if (ret != ERROR_SYSTEM_FILE_EOF) { - srs_error("read flv previous tag size failed. ret=%d", ret); - } - return ret; + if ((err = reader->read(previous_tag_size, 4, NULL)) != srs_success) { + return srs_error_wrap(err, "read flv previous tag size failed"); } - return ret; + return err; } SrsFlvVodStreamDecoder::SrsFlvVodStreamDecoder() { reader = NULL; - tag_stream = new SrsBuffer(); } SrsFlvVodStreamDecoder::~SrsFlvVodStreamDecoder() { - srs_freep(tag_stream); } -int SrsFlvVodStreamDecoder::initialize(ISrsReader* fr) +srs_error_t SrsFlvVodStreamDecoder::initialize(ISrsReader* fr) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(fr); reader = dynamic_cast(fr); if (!reader) { - ret = ERROR_EXPECT_FILE_IO; - srs_error("stream is not file io. ret=%d", ret); - return ret; + return srs_error_new(ERROR_EXPECT_FILE_IO, "stream is not file io"); } if (!reader->is_open()) { - ret = ERROR_KERNEL_FLV_STREAM_CLOSED; - srs_warn("stream is not open for decoder. ret=%d", ret); - return ret; + return srs_error_new(ERROR_KERNEL_FLV_STREAM_CLOSED, "stream is not open for decoder"); } - return ret; + return err; } -int SrsFlvVodStreamDecoder::read_header_ext(char header[13]) +srs_error_t SrsFlvVodStreamDecoder::read_header_ext(char header[13]) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(header); @@ -862,16 +823,16 @@ int SrsFlvVodStreamDecoder::read_header_ext(char header[13]) // 9bytes header and 4bytes first previous-tag-size int size = 13; - if ((ret = reader->read(header, size, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = reader->read(header, size, NULL)) != srs_success) { + return srs_error_wrap(err, "read header"); } - return ret; + return err; } -int SrsFlvVodStreamDecoder::read_sequence_header_summary(int64_t* pstart, int* psize) +srs_error_t SrsFlvVodStreamDecoder::read_sequence_header_summary(int64_t* pstart, int* psize) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(pstart); srs_assert(psize); @@ -896,13 +857,12 @@ int SrsFlvVodStreamDecoder::read_sequence_header_summary(int64_t* pstart, int* p int64_t av_sequence_offset_start = -1; int64_t av_sequence_offset_end = -1; for (;;) { - if ((ret = reader->read(tag_header, SRS_FLV_TAG_HEADER_SIZE, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = reader->read(tag_header, SRS_FLV_TAG_HEADER_SIZE, NULL)) != srs_success) { + return srs_error_wrap(err, "read tag header"); } - if ((ret = tag_stream->initialize(tag_header, SRS_FLV_TAG_HEADER_SIZE)) != ERROR_SUCCESS) { - return ret; - } + SrsBuffer* tag_stream = new SrsBuffer(tag_header, SRS_FLV_TAG_HEADER_SIZE); + SrsAutoFree(SrsBuffer, tag_stream); int8_t tag_type = tag_stream->read_1bytes(); int32_t data_size = tag_stream->read_3bytes(); @@ -957,30 +917,22 @@ int SrsFlvVodStreamDecoder::read_sequence_header_summary(int64_t* pstart, int* p *psize = (int)(av_sequence_offset_end - av_sequence_offset_start); } - return ret; + return err; } -int SrsFlvVodStreamDecoder::seek2(int64_t offset) +srs_error_t SrsFlvVodStreamDecoder::seek2(int64_t offset) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (offset >= reader->filesize()) { - ret = ERROR_SYSTEM_FILE_EOF; - srs_warn("flv fast decoder seek overflow file, " - "size=%" PRId64 ", offset=%" PRId64 ", ret=%d", - reader->filesize(), offset, ret); - return ret; + return srs_error_new(ERROR_SYSTEM_FILE_EOF, "flv fast decoder seek overflow file, size=%d, offset=%d", (int)reader->filesize(), (int)offset); } if (reader->seek2(offset) < 0) { - ret = ERROR_SYSTEM_FILE_SEEK; - srs_warn("flv fast decoder seek error, " - "size=%" PRId64 ", offset=%" PRId64 ", ret=%d", - reader->filesize(), offset, ret); - return ret; + return srs_error_new(ERROR_SYSTEM_FILE_SEEK, "flv fast decoder seek error, size=%d, offset=%d", (int)reader->filesize(), (int)offset); } - return ret; + return err; } diff --git a/trunk/src/kernel/srs_kernel_flv.hpp b/trunk/src/kernel/srs_kernel_flv.hpp index f04dbb9ff..9c6136016 100644 --- a/trunk/src/kernel/srs_kernel_flv.hpp +++ b/trunk/src/kernel/srs_kernel_flv.hpp @@ -294,7 +294,7 @@ public: * @remark user should never free the body. * @param pheader, the header to copy to the message. NULL to ignore. */ - virtual int create(SrsMessageHeader* pheader, char* body, int size); + virtual srs_error_t create(SrsMessageHeader* pheader, char* body, int size); }; /** @@ -398,14 +398,14 @@ public: * set the payload to NULL to prevent double free. * @remark payload of msg set to NULL if success. */ - virtual int create(SrsCommonMessage* msg); + virtual srs_error_t create(SrsCommonMessage* msg); /** * create shared ptr message, * from the header and payload. * @remark user should never free the payload. * @param pheader, the header to copy to the message. NULL to ignore. */ - virtual int create(SrsMessageHeader* pheader, char* payload, int size); + virtual srs_error_t create(SrsMessageHeader* pheader, char* payload, int size); /** * get current reference count. * when this object created, count set to 0. @@ -445,7 +445,6 @@ class SrsFlvTransmuxer private: ISrsWriter* writer; private: - SrsBuffer* tag_stream; char tag_header[SRS_FLV_TAG_HEADER_SIZE]; public: SrsFlvTransmuxer(); @@ -456,7 +455,7 @@ public: * @remark user can initialize multiple times to encode multiple flv files. * @remark, user must free the @param fw, flv encoder never close/free it. */ - virtual int initialize(ISrsWriter* fw); + virtual srs_error_t initialize(ISrsWriter* fw); public: /** * write flv header. @@ -465,8 +464,8 @@ public: * 2. PreviousTagSize0 UI32 Always 0 * that is, 9+4=13bytes. */ - virtual int write_header(); - virtual int write_header(char flv_header[9]); + virtual srs_error_t write_header(); + virtual srs_error_t write_header(char flv_header[9]); /** * write flv metadata. * @param type, the type of data, or other message type. @@ -476,13 +475,13 @@ public: * AMF0 object: the metadata object. * @remark assert data is not NULL. */ - virtual int write_metadata(char type, char* data, int size); + virtual srs_error_t write_metadata(char type, char* data, int size); /** * write audio/video packet. * @remark assert data is not NULL. */ - virtual int write_audio(int64_t timestamp, char* data, int size); - virtual int write_video(int64_t timestamp, char* data, int size); + virtual srs_error_t write_audio(int64_t timestamp, char* data, int size); + virtual srs_error_t write_video(int64_t timestamp, char* data, int size); public: /** * get the tag size, @@ -505,14 +504,14 @@ public: /** * write the tags in a time. */ - virtual int write_tags(SrsSharedPtrMessage** msgs, int count); + virtual srs_error_t write_tags(SrsSharedPtrMessage** msgs, int count); #endif private: - virtual int write_metadata_to_cache(char type, char* data, int size, char* cache); - virtual int write_audio_to_cache(int64_t timestamp, char* data, int size, char* cache); - virtual int write_video_to_cache(int64_t timestamp, char* data, int size, char* cache); - virtual int write_pts_to_cache(int size, char* cache); - virtual int write_tag(char* header, int header_size, char* tag, int tag_size); + virtual srs_error_t write_metadata_to_cache(char type, char* data, int size, char* cache); + virtual srs_error_t write_audio_to_cache(int64_t timestamp, char* data, int size, char* cache); + virtual srs_error_t write_video_to_cache(int64_t timestamp, char* data, int size, char* cache); + virtual srs_error_t write_pts_to_cache(int size, char* cache); + virtual srs_error_t write_tag(char* header, int header_size, char* tag, int tag_size); }; /** @@ -522,8 +521,6 @@ class SrsFlvDecoder { private: ISrsReader* reader; -private: - SrsBuffer* tag_stream; public: SrsFlvDecoder(); virtual ~SrsFlvDecoder(); @@ -533,28 +530,28 @@ public: * @remark user can initialize multiple times to decode multiple flv files. * @remark user must free the @param fr, flv decoder never close/free it */ - virtual int initialize(ISrsReader* fr); + virtual srs_error_t initialize(ISrsReader* fr); public: /** * read the flv header, donot including the 4bytes previous tag size. * @remark assert header not NULL. */ - virtual int read_header(char header[9]); + virtual srs_error_t read_header(char header[9]); /** * read the tag header infos. * @remark assert ptype/pdata_size/ptime not NULL. */ - virtual int read_tag_header(char* ptype, int32_t* pdata_size, uint32_t* ptime); + virtual srs_error_t read_tag_header(char* ptype, int32_t* pdata_size, uint32_t* ptime); /** * read the tag data. * @remark assert data not NULL. */ - virtual int read_tag_data(char* data, int32_t size); + virtual srs_error_t read_tag_data(char* data, int32_t size); /** * read the 4bytes previous tag size. * @remark assert previous_tag_size not NULL. */ - virtual int read_previous_tag_size(char previous_tag_size[4]); + virtual srs_error_t read_previous_tag_size(char previous_tag_size[4]); }; /** @@ -566,8 +563,6 @@ class SrsFlvVodStreamDecoder { private: SrsFileReader* reader; -private: - SrsBuffer* tag_stream; public: SrsFlvVodStreamDecoder(); virtual ~SrsFlvVodStreamDecoder(); @@ -577,14 +572,14 @@ public: * @remark user can initialize multiple times to decode multiple flv files. * @remark user must free the @param fr, flv decoder never close/free it. */ - virtual int initialize(ISrsReader* fr); + virtual srs_error_t initialize(ISrsReader* fr); public: /** * read the flv header and its size. * @param header, fill it 13bytes(9bytes header, 4bytes previous tag size). * @remark assert header not NULL. */ - virtual int read_header_ext(char header[13]); + virtual srs_error_t read_header_ext(char header[13]); /** * read the sequence header tags offset and its size. * @param pstart, the start offset of sequence header. @@ -592,12 +587,12 @@ public: * @remark we think the first audio/video is sequence header. * @remark assert pstart/psize not NULL. */ - virtual int read_sequence_header_summary(int64_t* pstart, int* psize); + virtual srs_error_t read_sequence_header_summary(int64_t* pstart, int* psize); public: /** * for start offset, seed to this position and response flv stream. */ - virtual int seek2(int64_t offset); + virtual srs_error_t seek2(int64_t offset); }; #endif diff --git a/trunk/src/kernel/srs_kernel_io.hpp b/trunk/src/kernel/srs_kernel_io.hpp index c8a74a4e7..081ede1f2 100644 --- a/trunk/src/kernel/srs_kernel_io.hpp +++ b/trunk/src/kernel/srs_kernel_io.hpp @@ -44,7 +44,7 @@ public: * Read bytes from reader. * @param nread How many bytes read from channel. NULL to ignore. */ - virtual int read(void* buf, size_t size, ssize_t* nread) = 0; + virtual srs_error_t read(void* buf, size_t size, ssize_t* nread) = 0; }; /** @@ -65,7 +65,7 @@ public: * @param seeked Upon successful completion, lseek() returns the resulting offset location as measured in bytes from * the beginning of the file. NULL to ignore. */ - virtual int lseek(off_t offset, int whence, off_t* seeked) = 0; + virtual srs_error_t lseek(off_t offset, int whence, off_t* seeked) = 0; }; /** @@ -91,7 +91,7 @@ public: * write bytes over writer. * @nwrite the actual written bytes. NULL to ignore. */ - virtual int write(void* buf, size_t size, ssize_t* nwrite) = 0; + virtual srs_error_t write(void* buf, size_t size, ssize_t* nwrite) = 0; }; /** @@ -109,7 +109,7 @@ public: * @remark for the HTTP FLV, to writev to improve performance. * @see https://github.com/ossrs/srs/issues/405 */ - virtual int writev(const iovec *iov, int iov_size, ssize_t* nwrite) = 0; + virtual srs_error_t writev(const iovec *iov, int iov_size, ssize_t* nwrite) = 0; }; /** diff --git a/trunk/src/kernel/srs_kernel_mp3.cpp b/trunk/src/kernel/srs_kernel_mp3.cpp index 3302aaa9e..eaa90e51a 100644 --- a/trunk/src/kernel/srs_kernel_mp3.cpp +++ b/trunk/src/kernel/srs_kernel_mp3.cpp @@ -39,37 +39,36 @@ using namespace std; #include #include #include +#include SrsMp3Transmuxer::SrsMp3Transmuxer() { writer = NULL; - tag_stream = new SrsBuffer(); } SrsMp3Transmuxer::~SrsMp3Transmuxer() { - srs_freep(tag_stream); } -int SrsMp3Transmuxer::initialize(SrsFileWriter* fw) +srs_error_t SrsMp3Transmuxer::initialize(SrsFileWriter* fw) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(fw); if (!fw->is_open()) { - ret = ERROR_KERNEL_MP3_STREAM_CLOSED; - srs_warn("stream is not open for encoder. ret=%d", ret); - return ret; + return srs_error_new(ERROR_KERNEL_MP3_STREAM_CLOSED, "stream is not open"); } writer = fw; - return ret; + return err; } -int SrsMp3Transmuxer::write_header() +srs_error_t SrsMp3Transmuxer::write_header() { + srs_error_t err = srs_success; + char id3[] = { (char)0x49, (char)0x44, (char)0x33, // ID3 (char)0x03, (char)0x00, // version @@ -80,27 +79,28 @@ int SrsMp3Transmuxer::write_header() (char)0x00, (char)0x00, (char)0x00, (char)0x00, // FrameSize (char)0x00, (char)0x00 // Flags }; - return writer->write(id3, sizeof(id3), NULL); + + if ((err = writer->write(id3, sizeof(id3), NULL)) != srs_success) { + return srs_error_wrap(err, "write id3"); + } + + return err; } -int SrsMp3Transmuxer::write_audio(int64_t timestamp, char* data, int size) +srs_error_t SrsMp3Transmuxer::write_audio(int64_t timestamp, char* data, int size) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(data); timestamp &= 0x7fffffff; - SrsBuffer* stream = tag_stream; - if ((ret = stream->initialize(data, size)) != ERROR_SUCCESS) { - return ret; - } + SrsBuffer* stream = new SrsBuffer(data, size); + SrsAutoFree(SrsBuffer, stream); // audio decode if (!stream->require(1)) { - ret = ERROR_MP3_DECODE_ERROR; - srs_error("mp3 decode audio sound_format failed. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP3_DECODE_ERROR, "decode sound_format"); } // @see: E.4.2 Audio Tags, video_file_format_spec_v10_1.pdf, page 76 @@ -112,18 +112,18 @@ int SrsMp3Transmuxer::write_audio(int64_t timestamp, char* data, int size) sound_format = (sound_format >> 4) & 0x0f; if ((SrsAudioCodecId)sound_format != SrsAudioCodecIdMP3) { - ret = ERROR_MP3_DECODE_ERROR; - srs_error("mp3 required, format=%d. ret=%d", sound_format, ret); - return ret; + return srs_error_new(ERROR_MP3_DECODE_ERROR, "mp3 required, format=%d", sound_format); } if (!stream->require(1)) { - ret = ERROR_MP3_DECODE_ERROR; - srs_error("mp3 decode aac_packet_type failed. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP3_DECODE_ERROR, "mp3 decode aac_packet_type failed"); + } + + if ((err = writer->write(data + stream->pos(), size - stream->pos(), NULL)) != srs_success) { + return srs_error_wrap(err, "write audio"); } - return writer->write(data + stream->pos(), size - stream->pos(), NULL); + return err; } #endif diff --git a/trunk/src/kernel/srs_kernel_mp3.hpp b/trunk/src/kernel/srs_kernel_mp3.hpp index 4eba610fb..bb9428cd2 100644 --- a/trunk/src/kernel/srs_kernel_mp3.hpp +++ b/trunk/src/kernel/srs_kernel_mp3.hpp @@ -40,8 +40,6 @@ class SrsMp3Transmuxer { private: SrsFileWriter* writer; -private: - SrsBuffer* tag_stream; public: SrsMp3Transmuxer(); virtual ~SrsMp3Transmuxer(); @@ -51,18 +49,18 @@ public: * @remark user can initialize multiple times to encode multiple mp3 files. * @remark, user must free the @param fw, mp3 encoder never close/free it. */ - virtual int initialize(SrsFileWriter* fw); + virtual srs_error_t initialize(SrsFileWriter* fw); public: /** * write mp3 id3 v2.3 header. * @see mp3.id3v2.3.0.pdf, http://id3.org/id3v2.3.0 */ - virtual int write_header(); + virtual srs_error_t write_header(); /** * write audio/video packet. * @remark assert data is not NULL. */ - virtual int write_audio(int64_t timestamp, char* data, int size); + virtual srs_error_t write_audio(int64_t timestamp, char* data, int size); }; #endif diff --git a/trunk/src/kernel/srs_kernel_mp4.cpp b/trunk/src/kernel/srs_kernel_mp4.cpp index 09e2c1cd1..084e8d4d6 100644 --- a/trunk/src/kernel/srs_kernel_mp4.cpp +++ b/trunk/src/kernel/srs_kernel_mp4.cpp @@ -196,27 +196,25 @@ void srs_mp4_string_write(SrsBuffer* buf, const string& v) buf->write_1bytes(0x00); } -int srs_mp4_string_read(SrsBuffer* buf, string& v, int left) +srs_error_t srs_mp4_string_read(SrsBuffer* buf, string& v, int left) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (left == 0) { - return ret; + return err; } char* start = buf->data() + buf->pos(); size_t len = strnlen(start, left); if ((int)len == left) { - ret = ERROR_MP4_BOX_STRING; - srs_error("MP4 string corrupt, left=%d. ret=%d", left, ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_STRING, "string corrupt, left=%d", left); } v.append(start, len); buf->skip((int)len + 1); - return ret; + return err; } SrsMp4DumpContext SrsMp4DumpContext::indent() @@ -339,16 +337,14 @@ stringstream& SrsMp4Box::dumps(stringstream& ss, SrsMp4DumpContext dc) return ss; } -int SrsMp4Box::discovery(SrsBuffer* buf, SrsMp4Box** ppbox) +srs_error_t SrsMp4Box::discovery(SrsBuffer* buf, SrsMp4Box** ppbox) { *ppbox = NULL; - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (!buf->require(8)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 discovery require 8 bytes space. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "requires 8 only %d bytes", buf->left()); } // Discovery the size and type. @@ -357,9 +353,7 @@ int SrsMp4Box::discovery(SrsBuffer* buf, SrsMp4Box** ppbox) SrsMp4BoxType type = (SrsMp4BoxType)buf->read_4bytes(); if (smallsize == SRS_MP4_USE_LARGE_SIZE) { if (!buf->require(8)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 discovery require 16 bytes space. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "requires 16 only %d bytes", buf->left()); } largesize = (uint64_t)buf->read_8bytes(); buf->skip(-8); @@ -368,9 +362,7 @@ int SrsMp4Box::discovery(SrsBuffer* buf, SrsMp4Box** ppbox) // Only support 31bits size. if (largesize > 0x7fffffff) { - ret = ERROR_MP4_BOX_OVERFLOW; - srs_error("MP4 discovery overflow 31bits, size=%" PRId64 ". ret=%d", largesize, ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_OVERFLOW, "overflow 31bits, largesize=%" PRId64, largesize); } SrsMp4Box* box = NULL; @@ -420,8 +412,7 @@ int SrsMp4Box::discovery(SrsBuffer* buf, SrsMp4Box** ppbox) case SrsMp4BoxTypeFREE: case SrsMp4BoxTypeSKIP: case SrsMp4BoxTypePASP: box = new SrsMp4FreeSpaceBox(type); break; default: - ret = ERROR_MP4_BOX_ILLEGAL_TYPE; - srs_error("MP4 illegal box type=%d. ret=%d", type, ret); + err = srs_error_new(ERROR_MP4_BOX_ILLEGAL_TYPE, "illegal box type=%d", type); break; } @@ -432,7 +423,7 @@ int SrsMp4Box::discovery(SrsBuffer* buf, SrsMp4Box** ppbox) *ppbox = box; } - return ret; + return err; } int SrsMp4Box::nb_bytes() @@ -448,9 +439,9 @@ int SrsMp4Box::nb_bytes() return sz; } -int SrsMp4Box::encode(SrsBuffer* buf) +srs_error_t SrsMp4Box::encode(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; uint64_t size = nb_bytes(); if (size > 0xffffffff) { @@ -461,78 +452,71 @@ int SrsMp4Box::encode(SrsBuffer* buf) start_pos = buf->pos(); - if ((ret = encode_header(buf)) != ERROR_SUCCESS) { - srs_error("MP4 encode box header failed. ret=%d", ret); - return ret; + if ((err = encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode box header"); } - if ((ret = encode_boxes(buf)) != ERROR_SUCCESS) { - srs_error("MP4 encode contained boxes failed. ret=%d", ret); - return ret; + if ((err = encode_boxes(buf)) != srs_success) { + return srs_error_wrap(err, "encode contained boxes"); } - return ret; + return err; } -int SrsMp4Box::decode(SrsBuffer* buf) +srs_error_t SrsMp4Box::decode(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; start_pos = buf->pos(); - if ((ret = decode_header(buf)) != ERROR_SUCCESS) { - srs_error("MP4 decode box header failed. ret=%d", ret); - return ret; + if ((err = decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode box header"); } - if ((ret = decode_boxes(buf)) != ERROR_SUCCESS) { - srs_error("MP4 decode contained boxes failed. ret=%d", ret); - return ret; + if ((err = decode_boxes(buf)) != srs_success) { + return srs_error_wrap(err, "decode contained boxes"); } - return ret; + return err; } -int SrsMp4Box::encode_boxes(SrsBuffer* buf) +srs_error_t SrsMp4Box::encode_boxes(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; vector::iterator it; for (it = boxes.begin(); it != boxes.end(); ++it) { SrsMp4Box* box = *it; - if ((ret = box->encode(buf)) != ERROR_SUCCESS) { - srs_error("MP4 encode contained box failed. ret=%d", ret); - return ret; + if ((err = box->encode(buf)) != srs_success) { + return srs_error_wrap(err, "encode contained box"); } } - return ret; + return err; } -int SrsMp4Box::decode_boxes(SrsBuffer* buf) +srs_error_t SrsMp4Box::decode_boxes(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; int left = left_space(buf); while (left > 0) { SrsMp4Box* box = NULL; - if ((ret = discovery(buf, &box)) != ERROR_SUCCESS) { - srs_error("MP4 discovery contained box failed. ret=%d", ret); - return ret; + if ((err = discovery(buf, &box)) != srs_success) { + return srs_error_wrap(err, "discovery contained box"); } srs_assert(box); - if ((ret = box->decode(buf)) != ERROR_SUCCESS) { + if ((err = box->decode(buf)) != srs_success) { srs_freep(box); - srs_error("MP4 decode contained box failed. ret=%d", ret); - return ret; + return srs_error_wrap(err, "decode contained box"); } boxes.push_back(box); left -= box->sz(); } - return ret; + return err; } int SrsMp4Box::nb_header() @@ -549,22 +533,18 @@ int SrsMp4Box::nb_header() return size; } -int SrsMp4Box::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4Box::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; // Only support 31bits size. if (sz() > 0x7fffffff) { - ret = ERROR_MP4_BOX_OVERFLOW; - srs_error("MP4 box size overflow 31bits, size=%" PRId64 ". ret=%d", sz(), ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_OVERFLOW, "box size overflow 31bits, size=%" PRId64, sz()); } int size = SrsMp4Box::nb_header(); if (!buf->require(size)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 box require %d bytes space. ret=%d", size, ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "requires %d only %d bytes", size, buf->left()); } buf->write_4bytes(smallsize); @@ -579,52 +559,42 @@ int SrsMp4Box::encode_header(SrsBuffer* buf) int lrsz = nb_header() - SrsMp4Box::nb_header(); if (!buf->require(lrsz)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 box require %d bytes space. ret=%d", lrsz, ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "box requires %v only %d bytes", lrsz, buf->left()); } - return ret; + return err; } -int SrsMp4Box::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4Box::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (!buf->require(8)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 box require 8 bytes space. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "requires 8 only %d bytes", buf->left()); } smallsize = (uint32_t)buf->read_4bytes(); type = (SrsMp4BoxType)buf->read_4bytes(); if (smallsize == SRS_MP4_EOF_SIZE) { srs_trace("MP4 box EOF."); - return ret; + return err; } if (smallsize == SRS_MP4_USE_LARGE_SIZE) { if (!buf->require(8)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 box require 8 bytes space. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "box requires 8 only %d bytes", buf->left()); } largesize = (uint64_t)buf->read_8bytes(); } // Only support 31bits size. if (sz() > 0x7fffffff) { - ret = ERROR_MP4_BOX_OVERFLOW; - srs_error("MP4 box size overflow 31bits, size=%" PRId64 ". ret=%d", sz(), ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_OVERFLOW, "box size overflow 31bits, size=%" PRId64, sz()); } if (type == SrsMp4BoxTypeUUID) { if (!buf->require(16)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 box requires 16 bytes space. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "box requires 16 only %d bytes", buf->left()); } usertype.resize(16); buf->read_bytes(&usertype[0], 16); @@ -633,12 +603,10 @@ int SrsMp4Box::decode_header(SrsBuffer* buf) // The left required size, determined by the default version(0). int lrsz = nb_header() - SrsMp4Box::nb_header(); if (!buf->require(lrsz)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 box requires %d bytes space. ret=%d", lrsz, ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "box requires %d only %d bytes", lrsz, buf->left()); } - return ret; + return err; } bool SrsMp4Box::boxes_in_header() @@ -666,38 +634,34 @@ int SrsMp4FullBox::nb_header() return SrsMp4Box::nb_header() + 1 + 3; } -int SrsMp4FullBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4FullBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } if (!buf->require(4)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 full box requires 4 bytes space. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "full box requires 4 only %d bytes", buf->left()); } buf->write_1bytes(version); buf->write_3bytes(flags); - return ret; + return err; } -int SrsMp4FullBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4FullBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } if (!buf->require(4)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 full box requires 4 bytes space. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "full box requires 4 only %d bytes", buf->left()); } flags = (uint32_t)buf->read_4bytes(); @@ -708,12 +672,10 @@ int SrsMp4FullBox::decode_header(SrsBuffer* buf) // The left required size, determined by the version. int lrsz = nb_header() - SrsMp4FullBox::nb_header(); if (!buf->require(lrsz)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 full box requires %d bytes space. ret=%d", lrsz, ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "full box requires %d only %d bytes", lrsz, buf->left()); } - return ret; + return err; } stringstream& SrsMp4FullBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -764,12 +726,12 @@ int SrsMp4FileTypeBox::nb_header() return (int)(SrsMp4Box::nb_header() + 8 + compatible_brands.size() * 4); } -int SrsMp4FileTypeBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4FileTypeBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes(major_brand); @@ -779,15 +741,15 @@ int SrsMp4FileTypeBox::encode_header(SrsBuffer* buf) buf->write_4bytes(compatible_brands[i]); } - return ret; + return err; } -int SrsMp4FileTypeBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4FileTypeBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } major_brand = (SrsMp4BoxBrand)buf->read_4bytes(); @@ -804,7 +766,7 @@ int SrsMp4FileTypeBox::decode_header(SrsBuffer* buf) compatible_brands[i] = (SrsMp4BoxBrand)buf->read_4bytes(); } - return ret; + return err; } stringstream& SrsMp4FileTypeBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -882,30 +844,30 @@ int SrsMp4MovieFragmentHeaderBox::nb_header() return SrsMp4FullBox::nb_header() + 4; } -int SrsMp4MovieFragmentHeaderBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4MovieFragmentHeaderBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes(sequence_number); - return ret; + return err; } -int SrsMp4MovieFragmentHeaderBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4MovieFragmentHeaderBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } sequence_number = buf->read_4bytes(); - return ret; + return err; } stringstream& SrsMp4MovieFragmentHeaderBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -999,12 +961,12 @@ int SrsMp4TrackFragmentHeaderBox::nb_header() return size; } -int SrsMp4TrackFragmentHeaderBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4TrackFragmentHeaderBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes(track_id); @@ -1025,15 +987,15 @@ int SrsMp4TrackFragmentHeaderBox::encode_header(SrsBuffer* buf) buf->write_4bytes(default_sample_flags); } - return ret; + return err; } -int SrsMp4TrackFragmentHeaderBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4TrackFragmentHeaderBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } track_id = buf->read_4bytes(); @@ -1054,7 +1016,7 @@ int SrsMp4TrackFragmentHeaderBox::decode_header(SrsBuffer* buf) default_sample_flags = buf->read_4bytes(); } - return ret; + return err; } stringstream& SrsMp4TrackFragmentHeaderBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -1104,12 +1066,12 @@ int SrsMp4TrackFragmentDecodeTimeBox::nb_header() return SrsMp4FullBox::nb_header() + (version? 8:4); } -int SrsMp4TrackFragmentDecodeTimeBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4TrackFragmentDecodeTimeBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } if (version) { @@ -1118,15 +1080,15 @@ int SrsMp4TrackFragmentDecodeTimeBox::encode_header(SrsBuffer* buf) buf->write_4bytes((uint32_t)base_media_decode_time); } - return ret; + return err; } -int SrsMp4TrackFragmentDecodeTimeBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4TrackFragmentDecodeTimeBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } if (version) { @@ -1135,7 +1097,7 @@ int SrsMp4TrackFragmentDecodeTimeBox::decode_header(SrsBuffer* buf) base_media_decode_time = buf->read_4bytes(); } - return ret; + return err; } stringstream& SrsMp4TrackFragmentDecodeTimeBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -1178,9 +1140,9 @@ int SrsMp4TrunEntry::nb_header() return size; } -int SrsMp4TrunEntry::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4TrunEntry::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if ((owner->flags&SrsMp4TrunFlagsSampleDuration) == SrsMp4TrunFlagsSampleDuration) { buf->write_4bytes(sample_duration); @@ -1201,12 +1163,12 @@ int SrsMp4TrunEntry::encode_header(SrsBuffer* buf) } } - return ret; + return err; } -int SrsMp4TrunEntry::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4TrunEntry::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if ((owner->flags&SrsMp4TrunFlagsSampleDuration) == SrsMp4TrunFlagsSampleDuration) { sample_duration = buf->read_4bytes(); @@ -1227,7 +1189,7 @@ int SrsMp4TrunEntry::decode_header(SrsBuffer* buf) } } - return ret; + return err; } stringstream& SrsMp4TrunEntry::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -1283,12 +1245,12 @@ int SrsMp4TrackFragmentRunBox::nb_header() return size; } -int SrsMp4TrackFragmentRunBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4TrackFragmentRunBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes(sample_count); @@ -1303,20 +1265,20 @@ int SrsMp4TrackFragmentRunBox::encode_header(SrsBuffer* buf) vector::iterator it; for (it = entries.begin(); it != entries.end(); ++it) { SrsMp4TrunEntry* entry = *it; - if ((ret = entry->encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = entry->encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode entry"); } } - return ret; + return err; } -int SrsMp4TrackFragmentRunBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4TrackFragmentRunBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } sample_count = buf->read_4bytes(); @@ -1332,12 +1294,12 @@ int SrsMp4TrackFragmentRunBox::decode_header(SrsBuffer* buf) SrsMp4TrunEntry* entry = new SrsMp4TrunEntry(this); entries.push_back(entry); - if ((ret = entry->decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = entry->decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode entry"); } } - return ret; + return err; } stringstream& SrsMp4TrackFragmentRunBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -1377,38 +1339,38 @@ int SrsMp4MediaDataBox::nb_bytes() return SrsMp4Box::nb_header() + nb_data; } -int SrsMp4MediaDataBox::encode(SrsBuffer* buf) +srs_error_t SrsMp4MediaDataBox::encode(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::encode(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::encode(buf)) != srs_success) { + return srs_error_wrap(err, "encode box"); } - return ret; + return err; } -int SrsMp4MediaDataBox::decode(SrsBuffer* buf) +srs_error_t SrsMp4MediaDataBox::decode(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::decode(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::decode(buf)) != srs_success) { + return srs_error_wrap(err, "decode box"); } nb_data = (int)(sz() - nb_header()); - return ret; + return err; } -int SrsMp4MediaDataBox::encode_boxes(SrsBuffer* buf) +srs_error_t SrsMp4MediaDataBox::encode_boxes(SrsBuffer* buf) { - return ERROR_SUCCESS; + return srs_success; } -int SrsMp4MediaDataBox::decode_boxes(SrsBuffer* buf) +srs_error_t SrsMp4MediaDataBox::decode_boxes(SrsBuffer* buf) { - return ERROR_SUCCESS; + return srs_success; } stringstream& SrsMp4MediaDataBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -1434,27 +1396,27 @@ int SrsMp4FreeSpaceBox::nb_header() return SrsMp4Box::nb_header() + (int)data.size(); } -int SrsMp4FreeSpaceBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4FreeSpaceBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } if (!data.empty()) { buf->write_bytes(&data[0], (int)data.size()); } - return ret; + return err; } -int SrsMp4FreeSpaceBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4FreeSpaceBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } int left = left_space(buf); @@ -1463,7 +1425,7 @@ int SrsMp4FreeSpaceBox::decode_header(SrsBuffer* buf) buf->read_bytes(&data[0], left); } - return ret; + return err; } stringstream& SrsMp4FreeSpaceBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -1585,14 +1547,26 @@ int SrsMp4MovieBox::nb_header() return SrsMp4Box::nb_header(); } -int SrsMp4MovieBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4MovieBox::encode_header(SrsBuffer* buf) { - return SrsMp4Box::encode_header(buf); + srs_error_t err = srs_success; + + if ((err = SrsMp4Box::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); + } + + return err; } -int SrsMp4MovieBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4MovieBox::decode_header(SrsBuffer* buf) { - return SrsMp4Box::decode_header(buf); + srs_error_t err = srs_success; + + if ((err = SrsMp4Box::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); + } + + return err; } SrsMp4MovieHeaderBox::SrsMp4MovieHeaderBox() : creation_time(0), modification_time(0), timescale(0), duration_in_tbn(0) @@ -1636,12 +1610,12 @@ int SrsMp4MovieHeaderBox::nb_header() return size; } -int SrsMp4MovieHeaderBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4MovieHeaderBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } if (version == 1) { @@ -1668,15 +1642,15 @@ int SrsMp4MovieHeaderBox::encode_header(SrsBuffer* buf) } buf->write_4bytes(next_track_ID); - return ret; + return err; } -int SrsMp4MovieHeaderBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4MovieHeaderBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } if (version == 1) { @@ -1701,7 +1675,7 @@ int SrsMp4MovieHeaderBox::decode_header(SrsBuffer* buf) buf->skip(24); next_track_ID = buf->read_4bytes(); - return ret; + return err; } stringstream& SrsMp4MovieHeaderBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -1749,12 +1723,12 @@ int SrsMp4TrackExtendsBox::nb_header() return SrsMp4FullBox::nb_header() + 4*5; } -int SrsMp4TrackExtendsBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4TrackExtendsBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes(track_ID); @@ -1763,15 +1737,15 @@ int SrsMp4TrackExtendsBox::encode_header(SrsBuffer* buf) buf->write_4bytes(default_sample_size); buf->write_4bytes(default_sample_flags); - return ret; + return err; } -int SrsMp4TrackExtendsBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4TrackExtendsBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } track_ID = buf->read_4bytes(); @@ -1780,7 +1754,7 @@ int SrsMp4TrackExtendsBox::decode_header(SrsBuffer* buf) default_sample_size = buf->read_4bytes(); default_sample_flags = buf->read_4bytes(); - return ret; + return err; } stringstream& SrsMp4TrackExtendsBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -1992,12 +1966,12 @@ int SrsMp4TrackHeaderBox::nb_header() return size; } -int SrsMp4TrackHeaderBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4TrackHeaderBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } if (version == 1) { @@ -2025,15 +1999,15 @@ int SrsMp4TrackHeaderBox::encode_header(SrsBuffer* buf) buf->write_4bytes(width); buf->write_4bytes(height); - return ret; + return err; } -int SrsMp4TrackHeaderBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4TrackHeaderBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } if (version == 1) { @@ -2061,7 +2035,7 @@ int SrsMp4TrackHeaderBox::decode_header(SrsBuffer* buf) width = buf->read_4bytes(); height = buf->read_4bytes(); - return ret; + return err; } stringstream& SrsMp4TrackHeaderBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -2129,12 +2103,12 @@ int SrsMp4EditListBox::nb_header() return size; } -int SrsMp4EditListBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4EditListBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes((int)entries.size()); @@ -2153,15 +2127,15 @@ int SrsMp4EditListBox::encode_header(SrsBuffer* buf) buf->write_2bytes(entry.media_rate_fraction); } - return ret; + return err; } -int SrsMp4EditListBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4EditListBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } uint32_t entry_count = buf->read_4bytes(); @@ -2183,7 +2157,7 @@ int SrsMp4EditListBox::decode_header(SrsBuffer* buf) entry.media_rate_fraction = buf->read_2bytes(); } - return ret; + return err; } stringstream& SrsMp4EditListBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -2319,12 +2293,12 @@ int SrsMp4MediaHeaderBox::nb_header() return size; } -int SrsMp4MediaHeaderBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4MediaHeaderBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } if (version == 1) { @@ -2342,15 +2316,15 @@ int SrsMp4MediaHeaderBox::encode_header(SrsBuffer* buf) buf->write_2bytes(language); buf->write_2bytes(pre_defined); - return ret; + return err; } -int SrsMp4MediaHeaderBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4MediaHeaderBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } if (version == 1) { @@ -2368,7 +2342,7 @@ int SrsMp4MediaHeaderBox::decode_header(SrsBuffer* buf) language = buf->read_2bytes(); buf->skip(2); - return ret; + return err; } stringstream& SrsMp4MediaHeaderBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -2411,12 +2385,12 @@ int SrsMp4HandlerReferenceBox::nb_header() return SrsMp4FullBox::nb_header()+4+4+12+srs_mp4_string_length(name); } -int SrsMp4HandlerReferenceBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4HandlerReferenceBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes(pre_defined); @@ -2426,27 +2400,26 @@ int SrsMp4HandlerReferenceBox::encode_header(SrsBuffer* buf) buf->write_4bytes(reserved[2]); srs_mp4_string_write(buf, name); - return ret; + return err; } -int SrsMp4HandlerReferenceBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4HandlerReferenceBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } buf->skip(4); handler_type = (SrsMp4HandlerType)buf->read_4bytes(); buf->skip(12); - if ((ret = srs_mp4_string_read(buf, name, left_space(buf))) != ERROR_SUCCESS) { - srs_error("MP4 hdlr read string failed. ret=%d", ret); - return ret; + if ((err = srs_mp4_string_read(buf, name, left_space(buf))) != srs_success) { + return srs_error_wrap(err, "hdlr read string"); } - return ret; + return err; } stringstream& SrsMp4HandlerReferenceBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -2536,12 +2509,12 @@ int SrsMp4VideoMeidaHeaderBox::nb_header() return SrsMp4FullBox::nb_header()+2+6; } -int SrsMp4VideoMeidaHeaderBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4VideoMeidaHeaderBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_2bytes(graphicsmode); @@ -2549,15 +2522,15 @@ int SrsMp4VideoMeidaHeaderBox::encode_header(SrsBuffer* buf) buf->write_2bytes(opcolor[1]); buf->write_2bytes(opcolor[2]); - return ret; + return err; } -int SrsMp4VideoMeidaHeaderBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4VideoMeidaHeaderBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } graphicsmode = buf->read_2bytes(); @@ -2565,7 +2538,7 @@ int SrsMp4VideoMeidaHeaderBox::decode_header(SrsBuffer* buf) opcolor[1] = buf->read_2bytes(); opcolor[2] = buf->read_2bytes(); - return ret; + return err; } SrsMp4SoundMeidaHeaderBox::SrsMp4SoundMeidaHeaderBox() @@ -2584,32 +2557,32 @@ int SrsMp4SoundMeidaHeaderBox::nb_header() return SrsMp4FullBox::nb_header()+2+2; } -int SrsMp4SoundMeidaHeaderBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4SoundMeidaHeaderBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_2bytes(balance); buf->write_2bytes(reserved); - return ret; + return err; } -int SrsMp4SoundMeidaHeaderBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4SoundMeidaHeaderBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } balance = buf->read_2bytes(); buf->skip(2); - return ret; + return err; } SrsMp4DataInformationBox::SrsMp4DataInformationBox() @@ -2660,9 +2633,9 @@ int SrsMp4DataEntryUrlBox::nb_header() return SrsMp4FullBox::nb_header()+srs_mp4_string_length(location); } -int SrsMp4DataEntryUrlBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4DataEntryUrlBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; // a 24-bit integer with flags; one flag is defined (x000001) which means that the media // data is in the same file as the Movie Box containing this data reference. @@ -2670,37 +2643,36 @@ int SrsMp4DataEntryUrlBox::encode_header(SrsBuffer* buf) flags = 0x01; } - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } if (!location.empty()) { srs_mp4_string_write(buf, location); } - return ret; + return err; } -int SrsMp4DataEntryUrlBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4DataEntryUrlBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } // a 24-bit integer with flags; one flag is defined (x000001) which means that the media // data is in the same file as the Movie Box containing this data reference. if (flags == 0x01) { - return ret; + return err; } - if ((ret = srs_mp4_string_read(buf, location, left_space(buf))) != ERROR_SUCCESS) { - srs_error("MP4 url read location failed. ret=%d", ret); - return ret; + if ((err = srs_mp4_string_read(buf, location, left_space(buf))) != srs_success) { + return srs_error_wrap(err, "url read location"); } - return ret; + return err; } stringstream& SrsMp4DataEntryUrlBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -2726,39 +2698,37 @@ int SrsMp4DataEntryUrnBox::nb_header() return SrsMp4FullBox::nb_header()+srs_mp4_string_length(location)+srs_mp4_string_length(name); } -int SrsMp4DataEntryUrnBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4DataEntryUrnBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4DataEntryBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4DataEntryBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode entry"); } srs_mp4_string_write(buf, location); srs_mp4_string_write(buf, name); - return ret; + return err; } -int SrsMp4DataEntryUrnBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4DataEntryUrnBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4DataEntryBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4DataEntryBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode entry"); } - if ((ret = srs_mp4_string_read(buf, location, left_space(buf))) != ERROR_SUCCESS) { - srs_error("MP4 urn read location failed. ret=%d", ret); - return ret; + if ((err = srs_mp4_string_read(buf, location, left_space(buf))) != srs_success) { + return srs_error_wrap(err, "urn read location"); } - if ((ret = srs_mp4_string_read(buf, name, left_space(buf))) != ERROR_SUCCESS) { - srs_error("MP4 urn read name failed. ret=%d", ret); - return ret; + if ((err = srs_mp4_string_read(buf, name, left_space(buf))) != srs_success) { + return srs_error_wrap(err, "urn read name"); } - return ret; + return err; } stringstream& SrsMp4DataEntryUrnBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -2813,12 +2783,12 @@ int SrsMp4DataReferenceBox::nb_header() return size; } -int SrsMp4DataReferenceBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4DataReferenceBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes((int32_t)entries.size()); @@ -2826,31 +2796,31 @@ int SrsMp4DataReferenceBox::encode_header(SrsBuffer* buf) vector::iterator it; for (it = entries.begin(); it != entries.end(); ++it) { SrsMp4DataEntryBox* entry = *it; - if ((ret = entry->encode(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = entry->encode(buf)) != srs_success) { + return srs_error_wrap(err, "encode entry"); } } - return ret; + return err; } -int SrsMp4DataReferenceBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4DataReferenceBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } uint32_t nb_entries = buf->read_4bytes(); for (uint32_t i = 0; i < nb_entries; i++) { SrsMp4Box* box = NULL; - if ((ret = SrsMp4Box::discovery(buf, &box)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::discovery(buf, &box)) != srs_success) { + return srs_error_wrap(err, "discovery box"); } - if ((ret = box->decode(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = box->decode(buf)) != srs_success) { + return srs_error_wrap(err, "decode box"); } SrsMp4FullBox* fbox = dynamic_cast(box); @@ -2868,7 +2838,7 @@ int SrsMp4DataReferenceBox::decode_header(SrsBuffer* buf) } } - return ret; + return err; } stringstream& SrsMp4DataReferenceBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -2982,14 +2952,26 @@ int SrsMp4SampleTableBox::nb_header() return SrsMp4Box::nb_header(); } -int SrsMp4SampleTableBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4SampleTableBox::encode_header(SrsBuffer* buf) { - return SrsMp4Box::encode_header(buf); + srs_error_t err = srs_success; + + if ((err = SrsMp4Box::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); + } + + return err; } -int SrsMp4SampleTableBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4SampleTableBox::decode_header(SrsBuffer* buf) { - return SrsMp4Box::decode_header(buf); + srs_error_t err = srs_success; + + if ((err = SrsMp4Box::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); + } + + return err; } SrsMp4SampleEntry::SrsMp4SampleEntry() : data_reference_index(0) @@ -3006,12 +2988,12 @@ int SrsMp4SampleEntry::nb_header() return SrsMp4Box::nb_header()+6+2; } -int SrsMp4SampleEntry::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4SampleEntry::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } for (int i = 0; i < 6; i++) { @@ -3019,21 +3001,21 @@ int SrsMp4SampleEntry::encode_header(SrsBuffer* buf) } buf->write_2bytes(data_reference_index); - return ret; + return err; } -int SrsMp4SampleEntry::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4SampleEntry::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } buf->skip(6); data_reference_index = buf->read_2bytes(); - return ret; + return err; } stringstream& SrsMp4SampleEntry::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -3081,12 +3063,12 @@ int SrsMp4VisualSampleEntry::nb_header() return SrsMp4SampleEntry::nb_header()+2+2+12+2+2+4+4+4+2+32+2+2; } -int SrsMp4VisualSampleEntry::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4VisualSampleEntry::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4SampleEntry::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4SampleEntry::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode entry"); } buf->write_2bytes(pre_defined0); @@ -3104,15 +3086,15 @@ int SrsMp4VisualSampleEntry::encode_header(SrsBuffer* buf) buf->write_2bytes(depth); buf->write_2bytes(pre_defined2); - return ret; + return err; } -int SrsMp4VisualSampleEntry::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4VisualSampleEntry::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4SampleEntry::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4SampleEntry::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode entry"); } buf->skip(2); @@ -3128,7 +3110,7 @@ int SrsMp4VisualSampleEntry::decode_header(SrsBuffer* buf) depth = buf->read_2bytes(); buf->skip(2); - return ret; + return err; } stringstream& SrsMp4VisualSampleEntry::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -3153,27 +3135,27 @@ int SrsMp4AvccBox::nb_header() return SrsMp4Box::nb_header() + (int)avc_config.size(); } -int SrsMp4AvccBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4AvccBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } if (!avc_config.empty()) { buf->write_bytes(&avc_config[0], (int)avc_config.size()); } - return ret; + return err; } -int SrsMp4AvccBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4AvccBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } int nb_config = left_space(buf); @@ -3182,7 +3164,7 @@ int SrsMp4AvccBox::decode_header(SrsBuffer* buf) buf->read_bytes(&avc_config[0], nb_config); } - return ret; + return err; } stringstream& SrsMp4AvccBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -3233,12 +3215,12 @@ int SrsMp4AudioSampleEntry::nb_header() return SrsMp4SampleEntry::nb_header()+8+2+2+2+2+4; } -int SrsMp4AudioSampleEntry::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4AudioSampleEntry::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4SampleEntry::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4SampleEntry::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode entry"); } buf->write_8bytes(reserved0); @@ -3248,15 +3230,15 @@ int SrsMp4AudioSampleEntry::encode_header(SrsBuffer* buf) buf->write_2bytes(reserved1); buf->write_4bytes(samplerate); - return ret; + return err; } -int SrsMp4AudioSampleEntry::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4AudioSampleEntry::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4SampleEntry::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4SampleEntry::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode entry"); } buf->skip(8); @@ -3266,7 +3248,7 @@ int SrsMp4AudioSampleEntry::decode_header(SrsBuffer* buf) buf->skip(2); samplerate = buf->read_4bytes(); - return ret; + return err; } stringstream& SrsMp4AudioSampleEntry::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -3317,15 +3299,13 @@ int SrsMp4BaseDescriptor::nb_bytes() return size; } -int SrsMp4BaseDescriptor::encode(SrsBuffer* buf) +srs_error_t SrsMp4BaseDescriptor::encode(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; int size = nb_bytes(); if (!buf->require(size)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 ES requires %d bytes space. ret=%d", size, ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "ES requires %d only %d bytes", size, buf->left()); } buf->write_1bytes((uint8_t)tag); @@ -3346,22 +3326,20 @@ int SrsMp4BaseDescriptor::encode(SrsBuffer* buf) } buf->write_1bytes(length&0x7f); - if ((ret = encode_payload(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = encode_payload(buf)) != srs_success) { + return srs_error_wrap(err, "encode payload"); } - return ret; + return err; } -int SrsMp4BaseDescriptor::decode(SrsBuffer* buf) +srs_error_t SrsMp4BaseDescriptor::decode(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; int size = nb_bytes(); if (!buf->require(size)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 ES requires %d bytes space. ret=%d", size, ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "requires %d only %d bytes", size, buf->left()); } tag = (SrsMp4ESTagEs)buf->read_1bytes(); @@ -3370,9 +3348,7 @@ int SrsMp4BaseDescriptor::decode(SrsBuffer* buf) int32_t length = 0x00; while ((v&0x80) == 0x80) { if (!buf->require(1)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 ES requires 1 byte space. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "ES requires 1 only %d bytes", buf->left()); } v = buf->read_1bytes(); @@ -3381,18 +3357,16 @@ int SrsMp4BaseDescriptor::decode(SrsBuffer* buf) vlen = length; if (!buf->require(vlen)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 ES requires %d bytes space. ret=%d", vlen, ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "ES requires %d only %d bytes", vlen, buf->left()); } start_pos = buf->pos(); - if ((ret = decode_payload(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = decode_payload(buf)) != srs_success) { + return srs_error_wrap(err, "decode payload"); } - return ret; + return err; } stringstream& SrsMp4BaseDescriptor::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -3415,20 +3389,20 @@ int32_t SrsMp4DecoderSpecificInfo::nb_payload() return (int)asc.size(); } -int SrsMp4DecoderSpecificInfo::encode_payload(SrsBuffer* buf) +srs_error_t SrsMp4DecoderSpecificInfo::encode_payload(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (!asc.empty()) { buf->write_bytes(&asc[0], (int)asc.size()); } - return ret; + return err; } -int SrsMp4DecoderSpecificInfo::decode_payload(SrsBuffer* buf) +srs_error_t SrsMp4DecoderSpecificInfo::decode_payload(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; int nb_asc = vlen; if (nb_asc) { @@ -3436,7 +3410,7 @@ int SrsMp4DecoderSpecificInfo::decode_payload(SrsBuffer* buf) buf->read_bytes(&asc[0], nb_asc); } - return ret; + return err; } stringstream& SrsMp4DecoderSpecificInfo::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -3469,9 +3443,9 @@ int32_t SrsMp4DecoderConfigDescriptor::nb_payload() return 13 + (decSpecificInfo? decSpecificInfo->nb_bytes():0); } -int SrsMp4DecoderConfigDescriptor::encode_payload(SrsBuffer* buf) +srs_error_t SrsMp4DecoderConfigDescriptor::encode_payload(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; buf->write_1bytes(objectTypeIndication); @@ -3484,16 +3458,16 @@ int SrsMp4DecoderConfigDescriptor::encode_payload(SrsBuffer* buf) buf->write_4bytes(maxBitrate); buf->write_4bytes(avgBitrate); - if (decSpecificInfo && (ret = decSpecificInfo->encode(buf)) != ERROR_SUCCESS) { - return ret; + if (decSpecificInfo && (err = decSpecificInfo->encode(buf)) != srs_success) { + return srs_error_wrap(err, "encode des specific info"); } - return ret; + return err; } -int SrsMp4DecoderConfigDescriptor::decode_payload(SrsBuffer* buf) +srs_error_t SrsMp4DecoderConfigDescriptor::decode_payload(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; objectTypeIndication = (SrsMp4ObjectType)buf->read_1bytes(); @@ -3509,12 +3483,12 @@ int SrsMp4DecoderConfigDescriptor::decode_payload(SrsBuffer* buf) int left = left_space(buf); if (left > 0) { decSpecificInfo = new SrsMp4DecoderSpecificInfo(); - if ((ret = decSpecificInfo->decode(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = decSpecificInfo->decode(buf)) != srs_success) { + return srs_error_wrap(err, "decode dec specific info"); } } - return ret; + return err; } stringstream& SrsMp4DecoderConfigDescriptor::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -3545,29 +3519,27 @@ int32_t SrsMp4SLConfigDescriptor::nb_payload() return 1; } -int SrsMp4SLConfigDescriptor::encode_payload(SrsBuffer* buf) +srs_error_t SrsMp4SLConfigDescriptor::encode_payload(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; buf->write_1bytes(predefined); - return ret; + return err; } -int SrsMp4SLConfigDescriptor::decode_payload(SrsBuffer* buf) +srs_error_t SrsMp4SLConfigDescriptor::decode_payload(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; predefined = buf->read_1bytes(); // TODO: FIXME: To support complete SL Config. if (predefined != 0x02) { - ret = ERROR_MP4_ESDS_SL_Config; - srs_error("MP4 illegal ESDS SL Config, predefined=%d. ret=%d", predefined, ret); - return ret; + return srs_error_new(ERROR_MP4_ESDS_SL_Config, "illegal ESDS SL Config, predefined=%d", predefined); } - return ret; + return err; } SrsMp4ES_Descriptor::SrsMp4ES_Descriptor() : ES_ID(0), dependsOn_ES_ID(0), OCR_ES_Id(0) @@ -3592,9 +3564,9 @@ int32_t SrsMp4ES_Descriptor::nb_payload() return size; } -int SrsMp4ES_Descriptor::encode_payload(SrsBuffer* buf) +srs_error_t SrsMp4ES_Descriptor::encode_payload(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; buf->write_2bytes(ES_ID); @@ -3610,27 +3582,27 @@ int SrsMp4ES_Descriptor::encode_payload(SrsBuffer* buf) if (URL_Flag && !URLstring.empty()) { buf->write_1bytes(URLstring.size()); - buf->write_bytes(&URLstring[0], URLstring.size()); + buf->write_bytes(&URLstring[0], (int)URLstring.size()); } if (OCRstreamFlag) { buf->write_2bytes(OCR_ES_Id); } - if ((ret = decConfigDescr.encode(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = decConfigDescr.encode(buf)) != srs_success) { + return srs_error_wrap(err, "encode dec config"); } - if ((ret = slConfigDescr.encode(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = slConfigDescr.encode(buf)) != srs_success) { + return srs_error_wrap(err, "encode sl config"); } - return ret; + return err; } -int SrsMp4ES_Descriptor::decode_payload(SrsBuffer* buf) +srs_error_t SrsMp4ES_Descriptor::decode_payload(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; ES_ID = buf->read_2bytes(); @@ -3642,25 +3614,19 @@ int SrsMp4ES_Descriptor::decode_payload(SrsBuffer* buf) if (streamDependenceFlag) { if (!buf->require(2)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 ES requires 2 bytes space. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "ES requires 2 only %v bytes", buf->left()); } dependsOn_ES_ID = buf->read_2bytes(); } if (URL_Flag) { if (!buf->require(1)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 ES requires 1 byte space. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "URLlength requires 1 only %v bytes", buf->left()); } uint8_t URLlength = buf->read_1bytes(); if (!buf->require(URLlength)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 ES requires %d bytes space. ret=%d", URLlength, ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "URL requires %d only %v bytes", URLlength, buf->left()); } URLstring.resize(URLlength); buf->read_bytes(&URLstring[0], URLlength); @@ -3668,22 +3634,20 @@ int SrsMp4ES_Descriptor::decode_payload(SrsBuffer* buf) if (OCRstreamFlag) { if (!buf->require(2)) { - ret = ERROR_MP4_BOX_REQUIRE_SPACE; - srs_error("MP4 ES requires 2 bytes space. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "OCR requires 2 only %v bytes", buf->left()); } OCR_ES_Id = buf->read_2bytes(); } - if ((ret = decConfigDescr.decode(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = decConfigDescr.decode(buf)) != srs_success) { + return srs_error_wrap(err, "decode dec config"); } - if ((ret = slConfigDescr.decode(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = slConfigDescr.decode(buf)) != srs_success) { + return srs_error_wrap(err, "decode sl config"); } - return ret; + return err; } stringstream& SrsMp4ES_Descriptor::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -3721,42 +3685,42 @@ int SrsMp4EsdsBox::nb_header() return SrsMp4FullBox::nb_header() + es->nb_bytes(); } -int SrsMp4EsdsBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4EsdsBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } int left = left_space(buf); SrsBuffer buffer(buf->data() + buf->pos(), left); - if ((ret = es->encode(&buffer)) != ERROR_SUCCESS) { - return ret; + if ((err = es->encode(&buffer)) != srs_success) { + return srs_error_wrap(err, "encode es"); } buf->skip(buffer.pos()); - return ret; + return err; } -int SrsMp4EsdsBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4EsdsBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } int left = left_space(buf); SrsBuffer buffer(buf->data() + buf->pos(), left); - if ((ret = es->decode(&buffer)) != ERROR_SUCCESS) { - return ret; + if ((err = es->decode(&buffer)) != srs_success) { + return srs_error_wrap(err, "decode es"); } buf->skip(buffer.pos()); - return ret; + return err; } stringstream& SrsMp4EsdsBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -3836,12 +3800,12 @@ int SrsMp4SampleDescriptionBox::nb_header() return size; } -int SrsMp4SampleDescriptionBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4SampleDescriptionBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes(entry_count()); @@ -3849,31 +3813,31 @@ int SrsMp4SampleDescriptionBox::encode_header(SrsBuffer* buf) vector::iterator it; for (it = entries.begin(); it != entries.end(); ++it) { SrsMp4SampleEntry* entry = *it; - if ((ret = entry->encode(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = entry->encode(buf)) != srs_success) { + return srs_error_wrap(err, "encode entry"); } } - return ret; + return err; } -int SrsMp4SampleDescriptionBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4SampleDescriptionBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } uint32_t nb_entries = buf->read_4bytes(); for (uint32_t i = 0; i < nb_entries; i++) { SrsMp4Box* box = NULL; - if ((ret = SrsMp4Box::discovery(buf, &box)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::discovery(buf, &box)) != srs_success) { + return srs_error_wrap(err, "discovery box"); } - if ((ret = box->decode(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = box->decode(buf)) != srs_success) { + return srs_error_wrap(err, "decode box"); } SrsMp4SampleEntry* entry = dynamic_cast(box); @@ -3884,7 +3848,7 @@ int SrsMp4SampleDescriptionBox::decode_header(SrsBuffer* buf) } } - return ret; + return err; } bool SrsMp4SampleDescriptionBox::boxes_in_header() @@ -3927,33 +3891,29 @@ SrsMp4DecodingTime2SampleBox::~SrsMp4DecodingTime2SampleBox() { } -int SrsMp4DecodingTime2SampleBox::initialize_counter() +srs_error_t SrsMp4DecodingTime2SampleBox::initialize_counter() { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; index = 0; if (index >= entries.size()) { - ret = ERROR_MP4_ILLEGAL_TIMESTAMP; - srs_error("MP4 illegal ts, empty stts. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_TIMESTAMP, "illegal ts, empty stts"); } count = entries[0].sample_count; - return ret; + return err; } -int SrsMp4DecodingTime2SampleBox::on_sample(uint32_t sample_index, SrsMp4SttsEntry** ppentry) +srs_error_t SrsMp4DecodingTime2SampleBox::on_sample(uint32_t sample_index, SrsMp4SttsEntry** ppentry) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (sample_index + 1 > count) { index++; if (index >= entries.size()) { - ret = ERROR_MP4_ILLEGAL_TIMESTAMP; - srs_error("MP4 illegal ts, stts overflow, count=%d. ret=%d", entries.size(), ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_TIMESTAMP, "illegal ts, stts overflow, count=%d", entries.size()); } count += entries[index].sample_count; @@ -3961,7 +3921,7 @@ int SrsMp4DecodingTime2SampleBox::on_sample(uint32_t sample_index, SrsMp4SttsEnt *ppentry = &entries[index]; - return ret; + return err; } int SrsMp4DecodingTime2SampleBox::nb_header() @@ -3969,12 +3929,12 @@ int SrsMp4DecodingTime2SampleBox::nb_header() return SrsMp4FullBox::nb_header() + 4 + 8 * (int)entries.size(); } -int SrsMp4DecodingTime2SampleBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4DecodingTime2SampleBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes((int)entries.size()); @@ -3984,15 +3944,15 @@ int SrsMp4DecodingTime2SampleBox::encode_header(SrsBuffer* buf) buf->write_4bytes(entry.sample_delta); } - return ret; + return err; } -int SrsMp4DecodingTime2SampleBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4DecodingTime2SampleBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } uint32_t entry_count = buf->read_4bytes(); @@ -4005,7 +3965,7 @@ int SrsMp4DecodingTime2SampleBox::decode_header(SrsBuffer* buf) entry.sample_delta = buf->read_4bytes(); } - return ret; + return err; } stringstream& SrsMp4DecodingTime2SampleBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -4044,33 +4004,29 @@ SrsMp4CompositionTime2SampleBox::~SrsMp4CompositionTime2SampleBox() { } -int SrsMp4CompositionTime2SampleBox::initialize_counter() +srs_error_t SrsMp4CompositionTime2SampleBox::initialize_counter() { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; index = 0; if (index >= entries.size()) { - ret = ERROR_MP4_ILLEGAL_TIMESTAMP; - srs_error("MP4 illegal ts, empty ctts. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_TIMESTAMP, "illegal ts, empty ctts"); } count = entries[0].sample_count; - return ret; + return err; } -int SrsMp4CompositionTime2SampleBox::on_sample(uint32_t sample_index, SrsMp4CttsEntry** ppentry) +srs_error_t SrsMp4CompositionTime2SampleBox::on_sample(uint32_t sample_index, SrsMp4CttsEntry** ppentry) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (sample_index + 1 > count) { index++; if (index >= entries.size()) { - ret = ERROR_MP4_ILLEGAL_TIMESTAMP; - srs_error("MP4 illegal ts, ctts overflow, count=%d. ret=%d", entries.size(), ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_TIMESTAMP, "illegal ts, ctts overflow, count=%d", entries.size()); } count += entries[index].sample_count; @@ -4078,7 +4034,7 @@ int SrsMp4CompositionTime2SampleBox::on_sample(uint32_t sample_index, SrsMp4Ctts *ppentry = &entries[index]; - return ret; + return err; } int SrsMp4CompositionTime2SampleBox::nb_header() @@ -4086,12 +4042,12 @@ int SrsMp4CompositionTime2SampleBox::nb_header() return SrsMp4FullBox::nb_header() + 4 + 8 * (int)entries.size(); } -int SrsMp4CompositionTime2SampleBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4CompositionTime2SampleBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes((int)entries.size()); @@ -4105,15 +4061,15 @@ int SrsMp4CompositionTime2SampleBox::encode_header(SrsBuffer* buf) } } - return ret; + return err; } -int SrsMp4CompositionTime2SampleBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4CompositionTime2SampleBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } uint32_t entry_count = buf->read_4bytes(); @@ -4130,7 +4086,7 @@ int SrsMp4CompositionTime2SampleBox::decode_header(SrsBuffer* buf) } } - return ret; + return err; } stringstream& SrsMp4CompositionTime2SampleBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -4174,12 +4130,12 @@ int SrsMp4SyncSampleBox::nb_header() return SrsMp4FullBox::nb_header() +4 +4*entry_count; } -int SrsMp4SyncSampleBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4SyncSampleBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes(entry_count); @@ -4188,15 +4144,15 @@ int SrsMp4SyncSampleBox::encode_header(SrsBuffer* buf) buf->write_4bytes(sample_number); } - return ret; + return err; } -int SrsMp4SyncSampleBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4SyncSampleBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } entry_count = buf->read_4bytes(); @@ -4207,7 +4163,7 @@ int SrsMp4SyncSampleBox::decode_header(SrsBuffer* buf) sample_numbers[i] = buf->read_4bytes(); } - return ret; + return err; } stringstream& SrsMp4SyncSampleBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -4274,12 +4230,12 @@ int SrsMp4Sample2ChunkBox::nb_header() return SrsMp4FullBox::nb_header() +4 + 12*entry_count; } -int SrsMp4Sample2ChunkBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4Sample2ChunkBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes(entry_count); @@ -4290,15 +4246,15 @@ int SrsMp4Sample2ChunkBox::encode_header(SrsBuffer* buf) buf->write_4bytes(entry.sample_description_index); } - return ret; + return err; } -int SrsMp4Sample2ChunkBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4Sample2ChunkBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } entry_count = buf->read_4bytes(); @@ -4312,7 +4268,7 @@ int SrsMp4Sample2ChunkBox::decode_header(SrsBuffer* buf) entry.sample_description_index = buf->read_4bytes(); } - return ret; + return err; } stringstream& SrsMp4Sample2ChunkBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -4346,12 +4302,12 @@ int SrsMp4ChunkOffsetBox::nb_header() return SrsMp4FullBox::nb_header() +4 +4*entry_count; } -int SrsMp4ChunkOffsetBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4ChunkOffsetBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes(entry_count); @@ -4359,15 +4315,15 @@ int SrsMp4ChunkOffsetBox::encode_header(SrsBuffer* buf) buf->write_4bytes(entries[i]); } - return ret; + return err; } -int SrsMp4ChunkOffsetBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4ChunkOffsetBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } entry_count = buf->read_4bytes(); @@ -4378,7 +4334,7 @@ int SrsMp4ChunkOffsetBox::decode_header(SrsBuffer* buf) entries[i] = buf->read_4bytes(); } - return ret; + return err; } stringstream& SrsMp4ChunkOffsetBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -4412,12 +4368,12 @@ int SrsMp4ChunkLargeOffsetBox::nb_header() return SrsMp4FullBox::nb_header() +4 +8*entry_count; } -int SrsMp4ChunkLargeOffsetBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4ChunkLargeOffsetBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes(entry_count); @@ -4425,15 +4381,15 @@ int SrsMp4ChunkLargeOffsetBox::encode_header(SrsBuffer* buf) buf->write_8bytes(entries[i]); } - return ret; + return err; } -int SrsMp4ChunkLargeOffsetBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4ChunkLargeOffsetBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } entry_count = buf->read_4bytes(); @@ -4444,7 +4400,7 @@ int SrsMp4ChunkLargeOffsetBox::decode_header(SrsBuffer* buf) entries[i] = buf->read_8bytes(); } - return ret; + return err; } stringstream& SrsMp4ChunkLargeOffsetBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -4473,22 +4429,21 @@ SrsMp4SampleSizeBox::~SrsMp4SampleSizeBox() srs_freepa(entry_sizes); } -int SrsMp4SampleSizeBox::get_sample_size(uint32_t sample_index, uint32_t* psample_size) +srs_error_t SrsMp4SampleSizeBox::get_sample_size(uint32_t sample_index, uint32_t* psample_size) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (sample_size != 0) { *psample_size = sample_size; - return ret; + return err; } if (sample_index >= sample_count) { - ret = ERROR_MP4_MOOV_OVERFLOW; - srs_error("MP4 stsz overflow, sample_count=%d. ret=%d", sample_count, ret); + return srs_error_new(ERROR_MP4_MOOV_OVERFLOW, "stsz overflow, sample_count=%d", sample_count); } *psample_size = entry_sizes[sample_index]; - return ret; + return err; } int SrsMp4SampleSizeBox::nb_header() @@ -4500,12 +4455,12 @@ int SrsMp4SampleSizeBox::nb_header() return size; } -int SrsMp4SampleSizeBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4SampleSizeBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } buf->write_4bytes(sample_size); @@ -4514,15 +4469,15 @@ int SrsMp4SampleSizeBox::encode_header(SrsBuffer* buf) buf->write_4bytes(entry_sizes[i]); } - return ret; + return err; } -int SrsMp4SampleSizeBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4SampleSizeBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4FullBox::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } sample_size = buf->read_4bytes(); @@ -4534,7 +4489,7 @@ int SrsMp4SampleSizeBox::decode_header(SrsBuffer* buf) entry_sizes[i] = buf->read_4bytes(); } - return ret; + return err; } stringstream& SrsMp4SampleSizeBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -4564,27 +4519,27 @@ int SrsMp4UserDataBox::nb_header() return SrsMp4Box::nb_header() + (int)data.size(); } -int SrsMp4UserDataBox::encode_header(SrsBuffer* buf) +srs_error_t SrsMp4UserDataBox::encode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::encode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::encode_header(buf)) != srs_success) { + return srs_error_wrap(err, "encode header"); } if (!data.empty()) { buf->write_bytes(&data[0], (int)data.size()); } - return ret; + return err; } -int SrsMp4UserDataBox::decode_header(SrsBuffer* buf) +srs_error_t SrsMp4UserDataBox::decode_header(SrsBuffer* buf) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; - if ((ret = SrsMp4Box::decode_header(buf)) != ERROR_SUCCESS) { - return ret; + if ((err = SrsMp4Box::decode_header(buf)) != srs_success) { + return srs_error_wrap(err, "decode header"); } int nb_data = left_space(buf); @@ -4593,7 +4548,7 @@ int SrsMp4UserDataBox::decode_header(SrsBuffer* buf) buf->read_bytes(&data[0], (int)data.size()); } - return ret; + return err; } stringstream& SrsMp4UserDataBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc) @@ -4652,21 +4607,21 @@ SrsMp4SampleManager::~SrsMp4SampleManager() samples.clear(); } -int SrsMp4SampleManager::load(SrsMp4MovieBox* moov) +srs_error_t SrsMp4SampleManager::load(SrsMp4MovieBox* moov) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; map tses; // Load samples from moov, merge to temp samples. - if ((ret = do_load(tses, moov)) != ERROR_SUCCESS) { + if ((err = do_load(tses, moov)) != srs_success) { map::iterator it; for (it = tses.begin(); it != tses.end(); ++it) { SrsMp4Sample* sample = it->second; srs_freep(sample); } - return ret; + return srs_error_wrap(err, "load mp4"); } // Dumps temp samples. @@ -4707,7 +4662,7 @@ int SrsMp4SampleManager::load(SrsMp4MovieBox* moov) } } - return ret; + return err; } SrsMp4Sample* SrsMp4SampleManager::at(uint32_t index) @@ -4723,9 +4678,9 @@ void SrsMp4SampleManager::append(SrsMp4Sample* sample) samples.push_back(sample); } -int SrsMp4SampleManager::write(SrsMp4MovieBox* moov) +srs_error_t SrsMp4SampleManager::write(SrsMp4MovieBox* moov) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; SrsMp4TrackBox* vide = moov->video(); if (vide) { @@ -4762,8 +4717,8 @@ int SrsMp4SampleManager::write(SrsMp4MovieBox* moov) SrsMp4ChunkOffsetBox* stco = new SrsMp4ChunkOffsetBox(); stbl->set_stco(stco); - if ((ret = write_track(SrsFrameTypeVideo, stts, stss, ctts, stsc, stsz, stco)) != ERROR_SUCCESS) { - return ret; + if ((err = write_track(SrsFrameTypeVideo, stts, stss, ctts, stsc, stsz, stco)) != srs_success) { + return srs_error_wrap(err, "write vide track"); } } @@ -4786,17 +4741,17 @@ int SrsMp4SampleManager::write(SrsMp4MovieBox* moov) SrsMp4ChunkOffsetBox* stco = new SrsMp4ChunkOffsetBox(); stbl->set_stco(stco); - if ((ret = write_track(SrsFrameTypeAudio, stts, stss, ctts, stsc, stsz, stco)) != ERROR_SUCCESS) { - return ret; + if ((err = write_track(SrsFrameTypeAudio, stts, stss, ctts, stsc, stsz, stco)) != srs_success) { + return srs_error_wrap(err, "write soun track"); } } - return ret; + return err; } -int SrsMp4SampleManager::write(SrsMp4MovieFragmentBox* moof, uint64_t& dts) +srs_error_t SrsMp4SampleManager::write(SrsMp4MovieFragmentBox* moof, uint64_t& dts) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; SrsMp4TrackFragmentBox* traf = moof->traf(); SrsMp4TrackFragmentRunBox* trun = traf->trun(); @@ -4834,14 +4789,14 @@ int SrsMp4SampleManager::write(SrsMp4MovieFragmentBox* moof, uint64_t& dts) trun->entries.push_back(entry); } - return ret; + return err; } -int SrsMp4SampleManager::write_track(SrsFrameType track, +srs_error_t SrsMp4SampleManager::write_track(SrsFrameType track, SrsMp4DecodingTime2SampleBox* stts, SrsMp4SyncSampleBox* stss, SrsMp4CompositionTime2SampleBox* ctts, SrsMp4Sample2ChunkBox* stsc, SrsMp4SampleSizeBox* stsz, SrsMp4ChunkOffsetBox* stco) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; SrsMp4SttsEntry stts_entry; vector stts_entries; @@ -4951,12 +4906,12 @@ int SrsMp4SampleManager::write_track(SrsFrameType track, } } - return ret; + return err; } -int SrsMp4SampleManager::do_load(map& tses, SrsMp4MovieBox* moov) +srs_error_t SrsMp4SampleManager::do_load(map& tses, SrsMp4MovieBox* moov) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; SrsMp4TrackBox* vide = moov->video(); if (vide) { @@ -4972,13 +4927,11 @@ int SrsMp4SampleManager::do_load(map& tses, SrsMp4Movie SrsMp4SyncSampleBox* stss = vide->stss(); if (!mdhd || !stco || !stsz || !stsc || !stts) { - ret = ERROR_MP4_ILLEGAL_TRACK; - srs_error("MP4 illegal track, empty mdhd/stco/stsz/stsc/stts, type=%d. ret=%d", tt, ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_TRACK, "illegal track, empty mdhd/stco/stsz/stsc/stts, type=%d", tt); } - if ((ret = load_trak(tses, SrsFrameTypeVideo, mdhd, stco, stsz, stsc, stts, ctts, stss)) != ERROR_SUCCESS) { - return ret; + if ((err = load_trak(tses, SrsFrameTypeVideo, mdhd, stco, stsz, stsc, stts, ctts, stss)) != srs_success) { + return srs_error_wrap(err, "load vide track"); } } @@ -4992,36 +4945,34 @@ int SrsMp4SampleManager::do_load(map& tses, SrsMp4Movie SrsMp4DecodingTime2SampleBox* stts = soun->stts(); if (!mdhd || !stco || !stsz || !stsc || !stts) { - ret = ERROR_MP4_ILLEGAL_TRACK; - srs_error("MP4 illegal track, empty mdhd/stco/stsz/stsc/stts, type=%d. ret=%d", tt, ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_TRACK, "illegal track, empty mdhd/stco/stsz/stsc/stts, type=%d", tt); } - if ((ret = load_trak(tses, SrsFrameTypeAudio, mdhd, stco, stsz, stsc, stts, NULL, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = load_trak(tses, SrsFrameTypeAudio, mdhd, stco, stsz, stsc, stts, NULL, NULL)) != srs_success) { + return srs_error_wrap(err, "load soun track"); } } - return ret; + return err; } -int SrsMp4SampleManager::load_trak(map& tses, SrsFrameType tt, +srs_error_t SrsMp4SampleManager::load_trak(map& tses, SrsFrameType tt, SrsMp4MediaHeaderBox* mdhd, SrsMp4ChunkOffsetBox* stco, SrsMp4SampleSizeBox* stsz, SrsMp4Sample2ChunkBox* stsc, SrsMp4DecodingTime2SampleBox* stts, SrsMp4CompositionTime2SampleBox* ctts, SrsMp4SyncSampleBox* stss) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; // Samples per chunk. stsc->initialize_counter(); // DTS box. - if ((ret = stts->initialize_counter()) != ERROR_SUCCESS) { - return ret; + if ((err = stts->initialize_counter()) != srs_success) { + return srs_error_wrap(err, "stts init counter"); } // CTS/PTS box. - if (ctts && (ret = ctts->initialize_counter()) != ERROR_SUCCESS) { - return ret; + if (ctts && (err = ctts->initialize_counter()) != srs_success) { + return srs_error_wrap(err, "ctts init counter"); } SrsMp4Sample* previous = NULL; @@ -5041,25 +4992,25 @@ int SrsMp4SampleManager::load_trak(map& tses, SrsFrameT sample->offset = stco->entries[ci] + sample_relative_offset; uint32_t sample_size = 0; - if ((ret = stsz->get_sample_size(sample->index, &sample_size)) != ERROR_SUCCESS) { + if ((err = stsz->get_sample_size(sample->index, &sample_size)) != srs_success) { srs_freep(sample); - return ret; + return srs_error_wrap(err, "stsz get sample size"); } sample_relative_offset += sample_size; SrsMp4SttsEntry* stts_entry = NULL; - if ((ret = stts->on_sample(sample->index, &stts_entry)) != ERROR_SUCCESS) { + if ((err = stts->on_sample(sample->index, &stts_entry)) != srs_success) { srs_freep(sample); - return ret; + return srs_error_wrap(err, "stts on sample"); } if (previous) { sample->pts = sample->dts = previous->dts + stts_entry->sample_delta; } SrsMp4CttsEntry* ctts_entry = NULL; - if (ctts && (ret = ctts->on_sample(sample->index, &ctts_entry)) != ERROR_SUCCESS) { + if (ctts && (err = ctts->on_sample(sample->index, &ctts_entry)) != srs_success) { srs_freep(sample); - return ret; + return srs_error_wrap(err, "ctts on sample"); } if (ctts_entry) { sample->pts = sample->dts + ctts_entry->sample_offset; @@ -5084,12 +5035,10 @@ int SrsMp4SampleManager::load_trak(map& tses, SrsFrameT // Check total samples. if (previous && previous->index + 1 != stsz->sample_count) { - ret = ERROR_MP4_ILLEGAL_SAMPLES; - srs_error("MP4 illegal samples count, expect=%d, actual=%d. ret=%d", stsz->sample_count, previous->index + 1, ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_SAMPLES, "illegal samples count, expect=%d, actual=%d", stsz->sample_count, previous->index + 1); } - return ret; + return err; } SrsMp4BoxReader::SrsMp4BoxReader() @@ -5103,16 +5052,16 @@ SrsMp4BoxReader::~SrsMp4BoxReader() srs_freepa(buf); } -int SrsMp4BoxReader::initialize(ISrsReadSeeker* rs) +srs_error_t SrsMp4BoxReader::initialize(ISrsReadSeeker* rs) { rsio = rs; - return ERROR_SUCCESS; + return srs_success; } -int SrsMp4BoxReader::read(SrsSimpleStream* stream, SrsMp4Box** ppbox) +srs_error_t SrsMp4BoxReader::read(SrsSimpleStream* stream, SrsMp4Box** ppbox) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; SrsMp4Box* box = NULL; while (true) { @@ -5128,11 +5077,8 @@ int SrsMp4BoxReader::read(SrsSimpleStream* stream, SrsMp4Box** ppbox) // Fill the stream util we can discovery box. while (stream->length() < (int)required) { ssize_t nread; - if ((ret = rsio->read(buf, SRS_MP4_BUF_SIZE, &nread)) != ERROR_SUCCESS) { - if (ret != ERROR_SYSTEM_FILE_EOF) { - srs_error("MP4 load failed, nread=%d, required=%d. ret=%d", nread, required, ret); - } - return ret; + if ((err = rsio->read(buf, SRS_MP4_BUF_SIZE, &nread)) != srs_success) { + return srs_error_wrap(err, "load failed, nread=%d, required=%d", nread, required); } srs_assert(nread > 0); @@ -5143,12 +5089,12 @@ int SrsMp4BoxReader::read(SrsSimpleStream* stream, SrsMp4Box** ppbox) SrsAutoFree(SrsBuffer, buffer); // Discovery the box with basic header. - if (!box && (ret = SrsMp4Box::discovery(buffer, &box)) != ERROR_SUCCESS) { - if (ret == ERROR_MP4_BOX_REQUIRE_SPACE) { + if (!box && (err = SrsMp4Box::discovery(buffer, &box)) != srs_success) { + if (srs_error_code(err) == ERROR_MP4_BOX_REQUIRE_SPACE) { + srs_freep(err); continue; } - srs_error("MP4 load box failed. ret=%d", ret); - return ret; + return srs_error_wrap(err, "load box failed"); } // When box is discoveried, check whether we can demux the whole box. @@ -5158,7 +5104,7 @@ int SrsMp4BoxReader::read(SrsSimpleStream* stream, SrsMp4Box** ppbox) continue; } - if (ret != ERROR_SUCCESS) { + if (err != srs_success) { srs_freep(box); } else { *ppbox = box; @@ -5167,12 +5113,12 @@ int SrsMp4BoxReader::read(SrsSimpleStream* stream, SrsMp4Box** ppbox) break; } - return ret; + return err; } -int SrsMp4BoxReader::skip(SrsMp4Box* box, SrsSimpleStream* stream) +srs_error_t SrsMp4BoxReader::skip(SrsMp4Box* box, SrsSimpleStream* stream) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; // For mdat, always skip the content. if (box->is_mdat()) { @@ -5182,15 +5128,15 @@ int SrsMp4BoxReader::skip(SrsMp4Box* box, SrsSimpleStream* stream) } else { stream->erase(stream->length()); } - if (offset > 0 && (ret = rsio->lseek(offset, SEEK_CUR, NULL)) != ERROR_SUCCESS) { - return ret; + if (offset > 0 && (err = rsio->lseek(offset, SEEK_CUR, NULL)) != srs_success) { + return srs_error_wrap(err, "io seek"); } } else { // Remove the consumed bytes. stream->erase((int)box->sz()); } - return ret; + return err; } SrsMp4Decoder::SrsMp4Decoder() @@ -5217,15 +5163,15 @@ SrsMp4Decoder::~SrsMp4Decoder() srs_freep(samples); } -int SrsMp4Decoder::initialize(ISrsReadSeeker* rs) +srs_error_t SrsMp4Decoder::initialize(ISrsReadSeeker* rs) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; srs_assert(rs); rsio = rs; - if ((ret = br->initialize(rs)) != ERROR_SUCCESS) { - return ret; + if ((err = br->initialize(rs)) != srs_success) { + return srs_error_wrap(err, "init box reader"); } // For mdat before moov, we must reset the offset to the mdat. @@ -5234,25 +5180,25 @@ int SrsMp4Decoder::initialize(ISrsReadSeeker* rs) while (true) { SrsMp4Box* box = NULL; - if ((ret = load_next_box(&box, 0)) != ERROR_SUCCESS) { - return ret; + if ((err = load_next_box(&box, 0)) != srs_success) { + return srs_error_wrap(err, "load box"); } if (box->is_ftyp()) { SrsMp4FileTypeBox* ftyp = dynamic_cast(box); - if ((ret = parse_ftyp(ftyp)) != ERROR_SUCCESS) { - return ret; + if ((err = parse_ftyp(ftyp)) != srs_success) { + return srs_error_wrap(err, "parse ftyp"); } } else if (box->is_mdat()) { off_t cur = 0; - if ((ret = rsio->lseek(0, SEEK_CUR, &cur)) != ERROR_SUCCESS) { - return ret; + if ((err = rsio->lseek(0, SEEK_CUR, &cur)) != srs_success) { + return srs_error_wrap(err, "io seek"); } offset = off_t(cur - box->sz()); } else if (box->is_moov()) { SrsMp4MovieBox* moov = dynamic_cast(box); - if ((ret = parse_moov(moov)) != ERROR_SUCCESS) { - return ret; + if ((err = parse_moov(moov)) != srs_success) { + return srs_error_wrap(err, "parse moov"); } break; } @@ -5261,22 +5207,22 @@ int SrsMp4Decoder::initialize(ISrsReadSeeker* rs) } if (brand == SrsMp4BoxBrandForbidden) { - ret = ERROR_MP4_BOX_ILLEGAL_SCHEMA; - srs_error("MP4 missing ftyp. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_ILLEGAL_SCHEMA, "missing ftyp"); } // Set the offset to the mdat. if (offset >= 0) { - return rsio->lseek(offset, SEEK_SET, ¤t_offset); + if ((err = rsio->lseek(offset, SEEK_SET, ¤t_offset)) != srs_success) { + return srs_error_wrap(err, "seek to mdat"); + } } - return ret; + return err; } -int SrsMp4Decoder::read_sample(SrsMp4HandlerType* pht, uint16_t* pft, uint16_t* pct, uint32_t* pdts, uint32_t* ppts, uint8_t** psample, uint32_t* pnb_sample) +srs_error_t SrsMp4Decoder::read_sample(SrsMp4HandlerType* pht, uint16_t* pft, uint16_t* pct, uint32_t* pdts, uint32_t* ppts, uint8_t** psample, uint32_t* pnb_sample) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (!avcc_written && !pavcc.empty()) { avcc_written = true; @@ -5290,7 +5236,7 @@ int SrsMp4Decoder::read_sample(SrsMp4HandlerType* pht, uint16_t* pft, uint16_t* *pft = SrsVideoAvcFrameTypeKeyFrame; *pct = SrsVideoAvcFrameTraitSequenceHeader; - return ret; + return err; } if (!asc_written && !pasc.empty()) { @@ -5305,12 +5251,12 @@ int SrsMp4Decoder::read_sample(SrsMp4HandlerType* pht, uint16_t* pft, uint16_t* *pft = 0x00; *pct = SrsAudioAacFrameTraitSequenceHeader; - return ret; + return err; } SrsMp4Sample* ps = samples->at(current_index++); if (!ps) { - return ERROR_SYSTEM_FILE_EOF; + return srs_error_new(ERROR_SYSTEM_FILE_EOF, "EOF"); } if (ps->type == SrsFrameTypeVideo) { @@ -5326,29 +5272,29 @@ int SrsMp4Decoder::read_sample(SrsMp4HandlerType* pht, uint16_t* pft, uint16_t* // Read sample from io, for we never preload the samples(too large). if (ps->offset != current_offset) { - if ((ret = rsio->lseek(ps->offset, SEEK_SET, ¤t_offset)) != ERROR_SUCCESS) { - return ret; + if ((err = rsio->lseek(ps->offset, SEEK_SET, ¤t_offset)) != srs_success) { + return srs_error_wrap(err, "seek to sample"); } } uint32_t nb_sample = ps->nb_data; uint8_t* sample = new uint8_t[nb_sample]; // TODO: FIXME: Use fully read. - if ((ret = rsio->read(sample, nb_sample, NULL)) != ERROR_SUCCESS) { + if ((err = rsio->read(sample, nb_sample, NULL)) != srs_success) { srs_freepa(sample); - return ret; + return srs_error_wrap(err, "read sample"); } *psample = sample; *pnb_sample = nb_sample; current_offset += nb_sample; - return ret; + return err; } -int SrsMp4Decoder::parse_ftyp(SrsMp4FileTypeBox* ftyp) +srs_error_t SrsMp4Decoder::parse_ftyp(SrsMp4FileTypeBox* ftyp) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; // File Type Box (ftyp) bool legal_brand = false; @@ -5363,33 +5309,27 @@ int SrsMp4Decoder::parse_ftyp(SrsMp4FileTypeBox* ftyp) } } if (!legal_brand) { - ret = ERROR_MP4_BOX_ILLEGAL_BRAND; - srs_error("MP4 brand is illegal, brand=%d. ret=%d", ftyp->major_brand, ret); - return ret; + return srs_error_new(ERROR_MP4_BOX_ILLEGAL_BRAND, "brand is illegal, brand=%d", ftyp->major_brand); } brand = ftyp->major_brand; - return ret; + return err; } -int SrsMp4Decoder::parse_moov(SrsMp4MovieBox* moov) +srs_error_t SrsMp4Decoder::parse_moov(SrsMp4MovieBox* moov) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; SrsMp4MovieHeaderBox* mvhd = moov->mvhd(); if (!mvhd) { - ret = ERROR_MP4_ILLEGAL_MOOV; - srs_error("MP4 missing mvhd. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_MOOV, "missing mvhd"); } SrsMp4TrackBox* vide = moov->video(); SrsMp4TrackBox* soun = moov->audio(); if (!vide && !soun) { - ret = ERROR_MP4_ILLEGAL_MOOV; - srs_error("MP4 missing audio and video track. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_MOOV, "missing audio and video track"); } SrsMp4AudioSampleEntry* mp4a = soun? soun->mp4a():NULL; @@ -5421,14 +5361,10 @@ int SrsMp4Decoder::parse_moov(SrsMp4MovieBox* moov) SrsMp4AvccBox* avcc = vide? vide->avcc():NULL; SrsMp4DecoderSpecificInfo* asc = soun? soun->asc():NULL; if (vide && !avcc) { - ret = ERROR_MP4_ILLEGAL_MOOV; - srs_error("MP4 missing video sequence header. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_MOOV, "missing video sequence header"); } if (soun && !asc) { - ret = ERROR_MP4_ILLEGAL_MOOV; - srs_error("MP4 missing audio sequence header. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_MOOV, "missing audio sequence header"); } vcodec = vide?vide->vide_codec():SrsVideoCodecIdForbidden; @@ -5442,9 +5378,8 @@ int SrsMp4Decoder::parse_moov(SrsMp4MovieBox* moov) } // Build the samples structure from moov. - if ((ret = samples->load(moov)) != ERROR_SUCCESS) { - srs_error("MP4 load samples failed. ret=%d", ret); - return ret; + if ((err = samples->load(moov)) != srs_success) { + return srs_error_wrap(err, "load samples"); } stringstream ss; @@ -5463,18 +5398,18 @@ int SrsMp4Decoder::parse_moov(SrsMp4MovieBox* moov) srs_trace("MP4 moov %s", ss.str().c_str()); - return ret; + return err; } -int SrsMp4Decoder::load_next_box(SrsMp4Box** ppbox, uint32_t required_box_type) +srs_error_t SrsMp4Decoder::load_next_box(SrsMp4Box** ppbox, uint32_t required_box_type) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; while (true) { SrsMp4Box* box = NULL; - if ((ret = do_load_next_box(&box, required_box_type)) != ERROR_SUCCESS) { + if ((err = do_load_next_box(&box, required_box_type)) != srs_success) { srs_freep(box); - return ret; + return srs_error_wrap(err, "load box"); } if (!required_box_type || (uint32_t)box->type == required_box_type) { @@ -5484,18 +5419,18 @@ int SrsMp4Decoder::load_next_box(SrsMp4Box** ppbox, uint32_t required_box_type) srs_freep(box); } - return ret; + return err; } -int SrsMp4Decoder::do_load_next_box(SrsMp4Box** ppbox, uint32_t required_box_type) +srs_error_t SrsMp4Decoder::do_load_next_box(SrsMp4Box** ppbox, uint32_t required_box_type) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; while (true) { SrsMp4Box* box = NULL; - if ((ret = br->read(stream, &box)) != ERROR_SUCCESS) { - return ret; + if ((err = br->read(stream, &box)) != srs_success) { + return srs_error_wrap(err, "read box"); } SrsBuffer* buffer = new SrsBuffer(stream->bytes(), stream->length()); @@ -5506,18 +5441,19 @@ int SrsMp4Decoder::do_load_next_box(SrsMp4Box** ppbox, uint32_t required_box_typ // 2. Matched box, when box type match the required type. // 3. Mdat box, always decode the mdat because we only decode the header of it. if (!required_box_type || (uint32_t)box->type == required_box_type || box->is_mdat()) { - ret = box->decode(buffer); + err = box->decode(buffer); } // Skip the box from stream, move stream to next box. // For mdat box, skip the content in stream or underylayer reader. // For other boxes, skip it from stream because we already decoded it or ignore it. - if (ret == ERROR_SUCCESS) { - ret = br->skip(box, stream); + if (err == srs_success) { + err = br->skip(box, stream); } - if (ret != ERROR_SUCCESS) { + if (err != srs_success) { srs_freep(box); + err = srs_error_wrap(err, "decode box"); } else { *ppbox = box; } @@ -5525,7 +5461,7 @@ int SrsMp4Decoder::do_load_next_box(SrsMp4Box** ppbox, uint32_t required_box_typ break; } - return ret; + return err; } SrsMp4Encoder::SrsMp4Encoder() @@ -5533,7 +5469,6 @@ SrsMp4Encoder::SrsMp4Encoder() wsio = NULL; mdat_bytes = 0; mdat_offset = 0; - buffer = new SrsBuffer(); nb_audios = nb_videos = 0; samples = new SrsMp4SampleManager(); aduration = vduration = 0; @@ -5549,12 +5484,11 @@ SrsMp4Encoder::SrsMp4Encoder() SrsMp4Encoder::~SrsMp4Encoder() { srs_freep(samples); - srs_freep(buffer); } -int SrsMp4Encoder::initialize(ISrsWriteSeeker* ws) +srs_error_t SrsMp4Encoder::initialize(ISrsWriteSeeker* ws) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; wsio = ws; @@ -5569,16 +5503,17 @@ int SrsMp4Encoder::initialize(ISrsWriteSeeker* ws) int nb_data = ftyp->nb_bytes(); std::vector data(nb_data); - if ((ret = buffer->initialize(&data[0], nb_data)) != ERROR_SUCCESS) { - return ret; - } - if ((ret = ftyp->encode(buffer)) != ERROR_SUCCESS) { - return ret; + + SrsBuffer* buffer = new SrsBuffer(&data[0], nb_data); + SrsAutoFree(SrsBuffer, buffer); + + if ((err = ftyp->encode(buffer)) != srs_success) { + return srs_error_wrap(err, "encode ftyp"); } // TODO: FIXME: Ensure write ok. - if ((ret = wsio->write(&data[0], nb_data, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = wsio->write(&data[0], nb_data, NULL)) != srs_success) { + return srs_error_wrap(err, "write ftyp"); } } @@ -5591,34 +5526,35 @@ int SrsMp4Encoder::initialize(ISrsWriteSeeker* ws) SrsAutoFree(SrsMp4MediaDataBox, mdat); // Update the mdat box from this offset. - if ((ret = wsio->lseek(0, SEEK_CUR, &mdat_offset)) != ERROR_SUCCESS) { - return ret; + if ((err = wsio->lseek(0, SEEK_CUR, &mdat_offset)) != srs_success) { + return srs_error_wrap(err, "seek to mdat"); } int nb_data = mdat->sz_header(); uint8_t* data = new uint8_t[nb_data]; SrsAutoFreeA(uint8_t, data); - if ((ret = buffer->initialize((char*)data, nb_data)) != ERROR_SUCCESS) { - return ret; - } - if ((ret = mdat->encode(buffer)) != ERROR_SUCCESS) { - return ret; + + SrsBuffer* buffer = new SrsBuffer((char*)data, nb_data); + SrsAutoFree(SrsBuffer, buffer); + + if ((err = mdat->encode(buffer)) != srs_success) { + return srs_error_wrap(err, "encode mdat"); } // TODO: FIXME: Ensure all bytes are writen. - if ((ret = wsio->write(data, nb_data, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = wsio->write(data, nb_data, NULL)) != srs_success) { + return srs_error_wrap(err, "write mdat"); } mdat_bytes = 0; } - return ret; + return err; } -int SrsMp4Encoder::write_sample(SrsMp4HandlerType ht, uint16_t ft, uint16_t ct, uint32_t dts, uint32_t pts, uint8_t* sample, uint32_t nb_sample) +srs_error_t SrsMp4Encoder::write_sample(SrsMp4HandlerType ht, uint16_t ft, uint16_t ct, uint32_t dts, uint32_t pts, uint8_t* sample, uint32_t nb_sample) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; SrsMp4Sample* ps = new SrsMp4Sample(); @@ -5626,9 +5562,9 @@ int SrsMp4Encoder::write_sample(SrsMp4HandlerType ht, uint16_t ft, uint16_t ct, bool vsh = (ht == SrsMp4HandlerTypeVIDE) && (ct == (uint16_t)SrsVideoAvcFrameTraitSequenceHeader); bool ash = (ht == SrsMp4HandlerTypeSOUN) && (ct == (uint16_t)SrsAudioAacFrameTraitSequenceHeader); if (vsh || ash) { - ret = copy_sequence_header(vsh, sample, nb_sample); + err = copy_sequence_header(vsh, sample, nb_sample); srs_freep(ps); - return ret; + return err; } if (ht == SrsMp4HandlerTypeVIDE) { @@ -5642,31 +5578,29 @@ int SrsMp4Encoder::write_sample(SrsMp4HandlerType ht, uint16_t ft, uint16_t ct, aduration = dts; } else { srs_freep(ps); - return ret; + return err; } ps->tbn = 1000; ps->dts = dts; ps->pts = pts; - if ((ret = do_write_sample(ps, sample, nb_sample)) != ERROR_SUCCESS) { + if ((err = do_write_sample(ps, sample, nb_sample)) != srs_success) { srs_freep(ps); - return ret; + return srs_error_wrap(err, "write sample"); } // Append to manager to build the moov. samples->append(ps); - return ret; + return err; } -int SrsMp4Encoder::flush() +srs_error_t SrsMp4Encoder::flush() { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (!nb_audios && !nb_videos) { - ret = ERROR_MP4_ILLEGAL_MOOV; - srs_error("MP4: Missing audio and video track. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_MOOV, "Missing audio and video track"); } // Write moov. @@ -5824,32 +5758,32 @@ int SrsMp4Encoder::flush() asc->asc = pasc;; } - if ((ret = samples->write(moov)) != ERROR_SUCCESS) { - return ret; + if ((err = samples->write(moov)) != srs_success) { + return srs_error_wrap(err, "write samples"); } int nb_data = moov->nb_bytes(); uint8_t* data = new uint8_t[nb_data]; SrsAutoFreeA(uint8_t, data); - if ((ret = buffer->initialize((char*)data, nb_data)) != ERROR_SUCCESS) { - return ret; - } - if ((ret = moov->encode(buffer)) != ERROR_SUCCESS) { - return ret; + SrsBuffer* buffer = new SrsBuffer((char*)data, nb_data); + SrsAutoFree(SrsBuffer, buffer); + + if ((err = moov->encode(buffer)) != srs_success) { + return srs_error_wrap(err, "encode moov"); } // TODO: FIXME: Ensure all bytes are writen. - if ((ret = wsio->write(data, nb_data, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = wsio->write(data, nb_data, NULL)) != srs_success) { + return srs_error_wrap(err, "write moov"); } } // Write mdat box. if (true) { // Update the mdat box header. - if ((ret = wsio->lseek(mdat_offset, SEEK_SET, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = wsio->lseek(mdat_offset, SEEK_SET, NULL)) != srs_success) { + return srs_error_wrap(err, "seek to mdat"); } // Write mdat box with size of data, @@ -5861,47 +5795,43 @@ int SrsMp4Encoder::flush() int nb_data = mdat->sz_header(); uint8_t* data = new uint8_t[nb_data]; SrsAutoFreeA(uint8_t, data); - if ((ret = buffer->initialize((char*)data, nb_data)) != ERROR_SUCCESS) { - return ret; - } + + SrsBuffer* buffer = new SrsBuffer((char*)data, nb_data); + SrsAutoFree(SrsBuffer, buffer); // TODO: FIXME: Support 64bits size. mdat->nb_data = (int)mdat_bytes; - if ((ret = mdat->encode(buffer)) != ERROR_SUCCESS) { - return ret; + if ((err = mdat->encode(buffer)) != srs_success) { + return srs_error_wrap(err, "encode mdat"); } // TODO: FIXME: Ensure all bytes are writen. - if ((ret = wsio->write(data, nb_data, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = wsio->write(data, nb_data, NULL)) != srs_success) { + return srs_error_wrap(err, "write mdat"); } } - return ret; + return err; } -int SrsMp4Encoder::copy_sequence_header(bool vsh, uint8_t* sample, uint32_t nb_sample) +srs_error_t SrsMp4Encoder::copy_sequence_header(bool vsh, uint8_t* sample, uint32_t nb_sample) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (vsh && !pavcc.empty()) { if (nb_sample == (uint32_t)pavcc.size() && srs_bytes_equals(sample, &pavcc[0], (int)pavcc.size())) { - return ret; + return err; } - ret = ERROR_MP4_AVCC_CHANGE; - srs_error("MP4 doesn't support avcc change. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_AVCC_CHANGE, "doesn't support avcc change"); } if (!vsh && !pasc.empty()) { if (nb_sample == (uint32_t)pasc.size() && srs_bytes_equals(sample, &pasc[0], (int)pasc.size())) { - return ret; + return err; } - ret = ERROR_MP4_ASC_CHANGE; - srs_error("MP4 doesn't support asc change. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_ASC_CHANGE, "doesn't support asc change"); } if (vsh) { @@ -5914,30 +5844,30 @@ int SrsMp4Encoder::copy_sequence_header(bool vsh, uint8_t* sample, uint32_t nb_s pasc = std::vector(sample, sample + nb_sample); } - return ret; + return err; } -int SrsMp4Encoder::do_write_sample(SrsMp4Sample* ps, uint8_t* sample, uint32_t nb_sample) +srs_error_t SrsMp4Encoder::do_write_sample(SrsMp4Sample* ps, uint8_t* sample, uint32_t nb_sample) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; ps->nb_data = nb_sample; // Never copy data, for we already writen to writer. ps->data = NULL; // Update the mdat box from this offset. - if ((ret = wsio->lseek(0, SEEK_CUR, &ps->offset)) != ERROR_SUCCESS) { - return ret; + if ((err = wsio->lseek(0, SEEK_CUR, &ps->offset)) != srs_success) { + return srs_error_wrap(err, "seek to offset in mdat"); } // TODO: FIXME: Ensure all bytes are writen. - if ((ret = wsio->write(sample, nb_sample, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = wsio->write(sample, nb_sample, NULL)) != srs_success) { + return srs_error_wrap(err, "write sample"); } mdat_bytes += nb_sample; - return ret; + return err; } SrsMp4M2tsInitEncoder::SrsMp4M2tsInitEncoder() @@ -5949,15 +5879,15 @@ SrsMp4M2tsInitEncoder::~SrsMp4M2tsInitEncoder() { } -int SrsMp4M2tsInitEncoder::initialize(ISrsWriter* w) +srs_error_t SrsMp4M2tsInitEncoder::initialize(ISrsWriter* w) { writer = w; - return ERROR_SUCCESS; + return srs_success; } -int SrsMp4M2tsInitEncoder::write(SrsFormat* format, bool video, int tid) +srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat* format, bool video, int tid) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; // Write ftyp box. SrsMp4FileTypeBox* ftyp = new SrsMp4FileTypeBox(); @@ -6169,22 +6099,19 @@ int SrsMp4M2tsInitEncoder::write(SrsFormat* format, bool video, int tid) SrsBuffer* buffer = new SrsBuffer(); SrsAutoFree(SrsBuffer, buffer); - if ((ret = buffer->initialize((char*)data, nb_data)) != ERROR_SUCCESS) { - return ret; - } - if ((ret = ftyp->encode(buffer)) != ERROR_SUCCESS) { - return ret; + if ((err = ftyp->encode(buffer)) != srs_success) { + return srs_error_wrap(err, "encode ftyp"); } - if ((ret = moov->encode(buffer)) != ERROR_SUCCESS) { - return ret; + if ((err = moov->encode(buffer)) != srs_success) { + return srs_error_wrap(err, "encode moov"); } - if ((ret = writer->write(data, nb_data, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = writer->write(data, nb_data, NULL)) != srs_success) { + return srs_error_wrap(err, "write ftyp and moov"); } - return ret; + return err; } SrsMp4M2tsSegmentEncoder::SrsMp4M2tsSegmentEncoder() @@ -6205,9 +6132,9 @@ SrsMp4M2tsSegmentEncoder::~SrsMp4M2tsSegmentEncoder() srs_freep(buffer); } -int SrsMp4M2tsSegmentEncoder::initialize(ISrsWriter* w, uint32_t sequence, uint64_t basetime, uint32_t tid) +srs_error_t SrsMp4M2tsSegmentEncoder::initialize(ISrsWriter* w, uint32_t sequence, uint64_t basetime, uint32_t tid) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; writer = w; track_id = tid; @@ -6225,27 +6152,28 @@ int SrsMp4M2tsSegmentEncoder::initialize(ISrsWriter* w, uint32_t sequence, uint6 int nb_data = styp->nb_bytes(); std::vector data(nb_data); - if ((ret = buffer->initialize(&data[0], nb_data)) != ERROR_SUCCESS) { - return ret; - } - if ((ret = styp->encode(buffer)) != ERROR_SUCCESS) { - return ret; + + SrsBuffer* buffer = new SrsBuffer(&data[0], nb_data); + SrsAutoFree(SrsBuffer, buffer); + + if ((err = styp->encode(buffer)) != srs_success) { + return srs_error_wrap(err, "encode styp"); } // TODO: FIXME: Ensure write ok. - if ((ret = writer->write(&data[0], nb_data, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = writer->write(&data[0], nb_data, NULL)) != srs_success) { + return srs_error_wrap(err, "write styp"); } data_offset = nb_data; } - return ret; + return err; } -int SrsMp4M2tsSegmentEncoder::write_sample(SrsMp4HandlerType ht, +srs_error_t SrsMp4M2tsSegmentEncoder::write_sample(SrsMp4HandlerType ht, uint16_t ft, uint32_t dts, uint32_t pts, uint8_t* sample, uint32_t nb_sample ) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; SrsMp4Sample* ps = new SrsMp4Sample(); @@ -6258,7 +6186,7 @@ int SrsMp4M2tsSegmentEncoder::write_sample(SrsMp4HandlerType ht, ps->index = nb_audios++; } else { srs_freep(ps); - return ret; + return err; } ps->tbn = 1000; @@ -6272,17 +6200,15 @@ int SrsMp4M2tsSegmentEncoder::write_sample(SrsMp4HandlerType ht, mdat_bytes += nb_sample; - return ret; + return err; } -int SrsMp4M2tsSegmentEncoder::flush(uint64_t& dts) +srs_error_t SrsMp4M2tsSegmentEncoder::flush(uint64_t& dts) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (!nb_audios && !nb_videos) { - ret = ERROR_MP4_ILLEGAL_MOOF; - srs_error("fMP4: Missing audio and video track. ret=%d", ret); - return ret; + return srs_error_new(ERROR_MP4_ILLEGAL_MOOF, "Missing audio and video track"); } // Create a mdat box. @@ -6319,8 +6245,8 @@ int SrsMp4M2tsSegmentEncoder::flush(uint64_t& dts) SrsMp4TrackFragmentRunBox* trun = new SrsMp4TrackFragmentRunBox(); traf->set_trun(trun); - if ((ret = samples->write(moof, dts)) != ERROR_SUCCESS) { - return ret; + if ((err = samples->write(moof, dts)) != srs_success) { + return srs_error_wrap(err, "write samples"); } int nb_data = moof->nb_bytes(); @@ -6328,17 +6254,17 @@ int SrsMp4M2tsSegmentEncoder::flush(uint64_t& dts) uint8_t* data = new uint8_t[nb_data]; SrsAutoFreeA(uint8_t, data); - if ((ret = buffer->initialize((char*)data, nb_data)) != ERROR_SUCCESS) { - return ret; - } - if ((ret = moof->encode(buffer)) != ERROR_SUCCESS) { - return ret; + SrsBuffer* buffer = new SrsBuffer((char*)data, nb_data); + SrsAutoFree(SrsBuffer, buffer); + + if ((err = moof->encode(buffer)) != srs_success) { + return srs_error_wrap(err, "encode moof"); } // TODO: FIXME: Ensure all bytes are writen. - if ((ret = writer->write(data, nb_data, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = writer->write(data, nb_data, NULL)) != srs_success) { + return srs_error_wrap(err, "write moof"); } } @@ -6349,16 +6275,17 @@ int SrsMp4M2tsSegmentEncoder::flush(uint64_t& dts) int nb_data = mdat->sz_header(); uint8_t* data = new uint8_t[nb_data]; SrsAutoFreeA(uint8_t, data); - if ((ret = buffer->initialize((char*)data, nb_data)) != ERROR_SUCCESS) { - return ret; - } - if ((ret = mdat->encode(buffer)) != ERROR_SUCCESS) { - return ret; + + SrsBuffer* buffer = new SrsBuffer((char*)data, nb_data); + SrsAutoFree(SrsBuffer, buffer); + + if ((err = mdat->encode(buffer)) != srs_success) { + return srs_error_wrap(err, "encode mdat"); } // TODO: FIXME: Ensure all bytes are writen. - if ((ret = writer->write(data, nb_data, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = writer->write(data, nb_data, NULL)) != srs_success) { + return srs_error_wrap(err, "write mdat"); } vector::iterator it; @@ -6366,12 +6293,12 @@ int SrsMp4M2tsSegmentEncoder::flush(uint64_t& dts) SrsMp4Sample* sample = *it; // TODO: FIXME: Ensure all bytes are writen. - if ((ret = writer->write(sample->data, sample->nb_data, NULL)) != ERROR_SUCCESS) { - return ret; + if ((err = writer->write(sample->data, sample->nb_data, NULL)) != srs_success) { + return srs_error_wrap(err, "write sample"); } } } - return ret; + return err; } diff --git a/trunk/src/kernel/srs_kernel_mp4.hpp b/trunk/src/kernel/srs_kernel_mp4.hpp index 234e47945..2b1a78e4d 100644 --- a/trunk/src/kernel/srs_kernel_mp4.hpp +++ b/trunk/src/kernel/srs_kernel_mp4.hpp @@ -222,15 +222,15 @@ public: * Discovery the box from buffer. * @param ppbox Output the discoveried box, which user must free it. */ - static int discovery(SrsBuffer* buf, SrsMp4Box** ppbox); + static srs_error_t discovery(SrsBuffer* buf, SrsMp4Box** ppbox); // Interface ISrsCodec public: virtual int nb_bytes(); - virtual int encode(SrsBuffer* buf); - virtual int decode(SrsBuffer* buf); + virtual srs_error_t encode(SrsBuffer* buf); + virtual srs_error_t decode(SrsBuffer* buf); protected: - virtual int encode_boxes(SrsBuffer* buf); - virtual int decode_boxes(SrsBuffer* buf); + virtual srs_error_t encode_boxes(SrsBuffer* buf); + virtual srs_error_t decode_boxes(SrsBuffer* buf); // Sub classes can override these functions for special codec. // @remark For mdat box, we use completely different codec. protected: @@ -238,10 +238,10 @@ protected: virtual int nb_header(); // It's not necessary to check the buffer, because we already know the size in parent function, // so we have checked the buffer is ok to write. - virtual int encode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); // It's not necessary to check the buffer, unless the box is not only determined by the verson. // Generally, it's not necessary, that is, all boxes is determinated by version. - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); // Whether there contained boxes in header. virtual bool boxes_in_header(); // @remark internal for template methods. @@ -266,8 +266,8 @@ public: virtual ~SrsMp4FullBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -298,8 +298,8 @@ public: virtual void set_compatible_brands(SrsMp4BoxBrand b0, SrsMp4BoxBrand b1, SrsMp4BoxBrand b2, SrsMp4BoxBrand b3); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -358,8 +358,8 @@ public: virtual ~SrsMp4MovieFragmentHeaderBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -451,8 +451,8 @@ public: virtual ~SrsMp4TrackFragmentHeaderBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -475,8 +475,8 @@ public: virtual ~SrsMp4TrackFragmentDecodeTimeBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -522,8 +522,8 @@ struct SrsMp4TrunEntry virtual ~SrsMp4TrunEntry(); virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -553,8 +553,8 @@ public: virtual ~SrsMp4TrackFragmentRunBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -622,13 +622,13 @@ public: virtual int nb_bytes(); // To encode the mdat box, the buf should only contains the sz_header(), // because the mdata only encode the header. - virtual int encode(SrsBuffer* buf); + virtual srs_error_t encode(SrsBuffer* buf); // To decode the mdat box, the buf should only contains the sz_header(), // because the mdat only decode the header. - virtual int decode(SrsBuffer* buf); + virtual srs_error_t decode(SrsBuffer* buf); protected: - virtual int encode_boxes(SrsBuffer* buf); - virtual int decode_boxes(SrsBuffer* buf); + virtual srs_error_t encode_boxes(SrsBuffer* buf); + virtual srs_error_t decode_boxes(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -646,8 +646,8 @@ public: virtual ~SrsMp4FreeSpaceBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -682,8 +682,8 @@ public: virtual int nb_soun_tracks(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); }; /** @@ -732,8 +732,8 @@ public: virtual uint64_t duration(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -783,8 +783,8 @@ public: virtual ~SrsMp4TrackExtendsBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -904,8 +904,8 @@ public: virtual ~SrsMp4TrackHeaderBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -968,8 +968,8 @@ public: virtual ~SrsMp4EditListBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1048,8 +1048,8 @@ public: virtual void set_language2(char v); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1080,8 +1080,8 @@ public: virtual bool is_audio(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1131,8 +1131,8 @@ public: virtual ~SrsMp4VideoMeidaHeaderBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); }; /** @@ -1153,8 +1153,8 @@ public: virtual ~SrsMp4SoundMeidaHeaderBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); }; /** @@ -1199,8 +1199,8 @@ public: virtual ~SrsMp4DataEntryUrlBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1218,8 +1218,8 @@ public: virtual ~SrsMp4DataEntryUrnBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1244,8 +1244,8 @@ public: virtual SrsMp4DataReferenceBox* append(SrsMp4DataEntryBox* v); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1286,8 +1286,8 @@ public: virtual void set_stss(SrsMp4SyncSampleBox* v); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); }; /** @@ -1307,8 +1307,8 @@ public: virtual ~SrsMp4SampleEntry(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1350,8 +1350,8 @@ public: virtual void set_avcC(SrsMp4AvccBox* v); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1369,8 +1369,8 @@ public: virtual ~SrsMp4AvccBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1399,8 +1399,8 @@ public: virtual SrsMp4DecoderSpecificInfo* asc(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1443,12 +1443,12 @@ public: // Interface ISrsCodec public: virtual int nb_bytes(); - virtual int encode(SrsBuffer* buf); - virtual int decode(SrsBuffer* buf); + virtual srs_error_t encode(SrsBuffer* buf); + virtual srs_error_t decode(SrsBuffer* buf); protected: virtual int32_t nb_payload() = 0; - virtual int encode_payload(SrsBuffer* buf) = 0; - virtual int decode_payload(SrsBuffer* buf) = 0; + virtual srs_error_t encode_payload(SrsBuffer* buf) = 0; + virtual srs_error_t decode_payload(SrsBuffer* buf) = 0; public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1485,8 +1485,8 @@ public: virtual ~SrsMp4DecoderSpecificInfo(); protected: virtual int32_t nb_payload(); - virtual int encode_payload(SrsBuffer* buf); - virtual int decode_payload(SrsBuffer* buf); + virtual srs_error_t encode_payload(SrsBuffer* buf); + virtual srs_error_t decode_payload(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1513,8 +1513,8 @@ public: virtual ~SrsMp4DecoderConfigDescriptor(); protected: virtual int32_t nb_payload(); - virtual int encode_payload(SrsBuffer* buf); - virtual int decode_payload(SrsBuffer* buf); + virtual srs_error_t encode_payload(SrsBuffer* buf); + virtual srs_error_t decode_payload(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1532,8 +1532,8 @@ public: virtual ~SrsMp4SLConfigDescriptor(); protected: virtual int32_t nb_payload(); - virtual int encode_payload(SrsBuffer* buf); - virtual int decode_payload(SrsBuffer* buf); + virtual srs_error_t encode_payload(SrsBuffer* buf); + virtual srs_error_t decode_payload(SrsBuffer* buf); }; /** @@ -1561,8 +1561,8 @@ public: virtual ~SrsMp4ES_Descriptor(); protected: virtual int32_t nb_payload(); - virtual int encode_payload(SrsBuffer* buf); - virtual int decode_payload(SrsBuffer* buf); + virtual srs_error_t encode_payload(SrsBuffer* buf); + virtual srs_error_t decode_payload(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1585,8 +1585,8 @@ public: virtual SrsMp4DecoderSpecificInfo* asc(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1615,8 +1615,8 @@ public: virtual SrsMp4SampleDescriptionBox* append(SrsMp4SampleEntry* v); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); virtual bool boxes_in_header(); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); @@ -1661,13 +1661,13 @@ public: virtual ~SrsMp4DecodingTime2SampleBox(); public: // Initialize the counter. - virtual int initialize_counter(); + virtual srs_error_t initialize_counter(); // When got an sample, index starts from 0. - virtual int on_sample(uint32_t sample_index, SrsMp4SttsEntry** ppentry); + virtual srs_error_t on_sample(uint32_t sample_index, SrsMp4SttsEntry** ppentry); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1715,13 +1715,13 @@ public: virtual ~SrsMp4CompositionTime2SampleBox(); public: // Initialize the counter. - virtual int initialize_counter(); + virtual srs_error_t initialize_counter(); // When got an sample, index starts from 0. - virtual int on_sample(uint32_t sample_index, SrsMp4CttsEntry** ppentry); + virtual srs_error_t on_sample(uint32_t sample_index, SrsMp4CttsEntry** ppentry); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1748,8 +1748,8 @@ public: virtual bool is_sync(uint32_t sample_index); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1804,8 +1804,8 @@ public: virtual SrsMp4StscEntry* on_chunk(uint32_t chunk_index); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1830,8 +1830,8 @@ public: virtual ~SrsMp4ChunkOffsetBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1856,8 +1856,8 @@ public: virtual ~SrsMp4ChunkLargeOffsetBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1886,11 +1886,11 @@ public: virtual ~SrsMp4SampleSizeBox(); public: // Get the size of sample. - virtual int get_sample_size(uint32_t sample_index, uint32_t* psample_size); + virtual srs_error_t get_sample_size(uint32_t sample_index, uint32_t* psample_size); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1910,8 +1910,8 @@ public: virtual ~SrsMp4UserDataBox(); protected: virtual int nb_header(); - virtual int encode_header(SrsBuffer* buf); - virtual int decode_header(SrsBuffer* buf); + virtual srs_error_t encode_header(SrsBuffer* buf); + virtual srs_error_t decode_header(SrsBuffer* buf); public: virtual std::stringstream& dumps_detail(std::stringstream& ss, SrsMp4DumpContext dc); }; @@ -1972,28 +1972,28 @@ public: virtual ~SrsMp4SampleManager(); public: // Load the samples from moov. There must be atleast one track. - virtual int load(SrsMp4MovieBox* moov); + virtual srs_error_t load(SrsMp4MovieBox* moov); // Get the sample at index position. // @remark NULL if exceed the max index. virtual SrsMp4Sample* at(uint32_t index); // Append the sample to the tail of manager. virtual void append(SrsMp4Sample* sample); // Write the samples info to moov. - virtual int write(SrsMp4MovieBox* moov); + virtual srs_error_t write(SrsMp4MovieBox* moov); // Write the samples info to moof. // @param The dts is the dts of last segment. - virtual int write(SrsMp4MovieFragmentBox* moof, uint64_t& dts); + virtual srs_error_t write(SrsMp4MovieFragmentBox* moof, uint64_t& dts); private: - virtual int write_track(SrsFrameType track, + virtual srs_error_t write_track(SrsFrameType track, SrsMp4DecodingTime2SampleBox* stts, SrsMp4SyncSampleBox* stss, SrsMp4CompositionTime2SampleBox* ctts, SrsMp4Sample2ChunkBox* stsc, SrsMp4SampleSizeBox* stsz, SrsMp4ChunkOffsetBox* stco); - virtual int do_load(std::map& tses, SrsMp4MovieBox* moov); + virtual srs_error_t do_load(std::map& tses, SrsMp4MovieBox* moov); private: // Load the samples of track from stco, stsz and stsc. // @param tses The temporary samples, key is offset, value is sample. // @param tt The type of sample, convert to flv tag type. // TODO: Support co64 for stco. - virtual int load_trak(std::map& tses, SrsFrameType tt, + virtual srs_error_t load_trak(std::map& tses, SrsFrameType tt, SrsMp4MediaHeaderBox* mdhd, SrsMp4ChunkOffsetBox* stco, SrsMp4SampleSizeBox* stsz, SrsMp4Sample2ChunkBox* stsc, SrsMp4DecodingTime2SampleBox* stts, SrsMp4CompositionTime2SampleBox* ctts, SrsMp4SyncSampleBox* stss); }; @@ -2012,12 +2012,12 @@ public: SrsMp4BoxReader(); virtual ~SrsMp4BoxReader(); public: - virtual int initialize(ISrsReadSeeker* rs); + virtual srs_error_t initialize(ISrsReadSeeker* rs); public: // Read a MP4 box to pbox, the stream is fill with the bytes of box to decode. - virtual int read(SrsSimpleStream* stream, SrsMp4Box** ppbox); + virtual srs_error_t read(SrsSimpleStream* stream, SrsMp4Box** ppbox); // Skip the box from stream, and skip in file if need. - virtual int skip(SrsMp4Box* box, SrsSimpleStream* stream); + virtual srs_error_t skip(SrsMp4Box* box, SrsSimpleStream* stream); }; /** @@ -2075,7 +2075,7 @@ public: * Initialize the decoder with a reader r. * @param r The underlayer io reader, user must manage it. */ - virtual int initialize(ISrsReadSeeker* rs); + virtual srs_error_t initialize(ISrsReadSeeker* rs); /** * Read a sample from mp4. * @param pht The sample hanler type, audio/soun or video/vide. @@ -2087,17 +2087,17 @@ public: * @param psample The output payload, user must free it. * @remark The decoder will generate the first two audio/video sequence header. */ - virtual int read_sample(SrsMp4HandlerType* pht, uint16_t* pft, uint16_t* pct, + virtual srs_error_t read_sample(SrsMp4HandlerType* pht, uint16_t* pft, uint16_t* pct, uint32_t* pdts, uint32_t* ppts, uint8_t** psample, uint32_t* pnb_sample); private: - virtual int parse_ftyp(SrsMp4FileTypeBox* ftyp); - virtual int parse_moov(SrsMp4MovieBox* moov); + virtual srs_error_t parse_ftyp(SrsMp4FileTypeBox* ftyp); + virtual srs_error_t parse_moov(SrsMp4MovieBox* moov); private: // Load the next box from reader. // @param required_box_type The box type required, 0 for any box. - virtual int load_next_box(SrsMp4Box** ppbox, uint32_t required_box_type); + virtual srs_error_t load_next_box(SrsMp4Box** ppbox, uint32_t required_box_type); // @remark Never load the mdat box content, for it's too large. - virtual int do_load_next_box(SrsMp4Box** ppbox, uint32_t required_box_type); + virtual srs_error_t do_load_next_box(SrsMp4Box** ppbox, uint32_t required_box_type); }; /** @@ -2107,7 +2107,6 @@ class SrsMp4Encoder { private: ISrsWriteSeeker* wsio; - SrsBuffer* buffer; // The mdat offset at file, we must update the header when flush. off_t mdat_offset; // The mdat size in bytes, we must update it to the mdat box header. @@ -2151,7 +2150,7 @@ public: public: // Initialize the encoder with a writer and seeker ws. // @param ws The underlayer io writer and seeker, user must manage it. - virtual int initialize(ISrsWriteSeeker* ws); + virtual srs_error_t initialize(ISrsWriteSeeker* ws); // Write a sample to mp4. // @param ht, The sample handler type, audio/soun or video/vide. // @param ft, The frame type. For video, it's SrsVideoAvcFrameType. @@ -2160,13 +2159,13 @@ public: // @param pts The output pts in milliseconds. // @param sample The output payload, user must free it. // @param nb_sample The output size of payload. - virtual int write_sample(SrsMp4HandlerType ht, uint16_t ft, uint16_t ct, + virtual srs_error_t write_sample(SrsMp4HandlerType ht, uint16_t ft, uint16_t ct, uint32_t dts, uint32_t pts, uint8_t* sample, uint32_t nb_sample); // Flush the encoder, to write the moov. - virtual int flush(); + virtual srs_error_t flush(); private: - virtual int copy_sequence_header(bool vsh, uint8_t* sample, uint32_t nb_sample); - virtual int do_write_sample(SrsMp4Sample* ps, uint8_t* sample, uint32_t nb_sample); + virtual srs_error_t copy_sequence_header(bool vsh, uint8_t* sample, uint32_t nb_sample); + virtual srs_error_t do_write_sample(SrsMp4Sample* ps, uint8_t* sample, uint32_t nb_sample); }; /** @@ -2181,9 +2180,9 @@ public: virtual ~SrsMp4M2tsInitEncoder(); public: // Initialize the encoder with a writer w. - virtual int initialize(ISrsWriter* w); + virtual srs_error_t initialize(ISrsWriter* w); // Write the sequence header. - virtual int write(SrsFormat* format, bool video, int tid); + virtual srs_error_t write(SrsFormat* format, bool video, int tid); }; /** @@ -2210,7 +2209,7 @@ public: virtual ~SrsMp4M2tsSegmentEncoder(); public: // Initialize the encoder with a writer w. - virtual int initialize(ISrsWriter* w, uint32_t sequence, uint64_t basetime, uint32_t tid); + virtual srs_error_t initialize(ISrsWriter* w, uint32_t sequence, uint64_t basetime, uint32_t tid); // Cache a sample. // @param ht, The sample handler type, audio/soun or video/vide. // @param ft, The frame type. For video, it's SrsVideoAvcFrameType. @@ -2219,10 +2218,10 @@ public: // @param sample The output payload, user must free it. // @param nb_sample The output size of payload. // @remark All samples are RAW AAC/AVC data, because sequence header is writen to init.mp4. - virtual int write_sample(SrsMp4HandlerType ht, uint16_t ft, + virtual srs_error_t write_sample(SrsMp4HandlerType ht, uint16_t ft, uint32_t dts, uint32_t pts, uint8_t* sample, uint32_t nb_sample); // Flush the encoder, to write the moof and mdat. - virtual int flush(uint64_t& dts); + virtual srs_error_t flush(uint64_t& dts); }; #endif diff --git a/trunk/src/kernel/srs_kernel_ts.cpp b/trunk/src/kernel/srs_kernel_ts.cpp index 0c0dab6f8..8b46cffcc 100644 --- a/trunk/src/kernel/srs_kernel_ts.cpp +++ b/trunk/src/kernel/srs_kernel_ts.cpp @@ -374,7 +374,6 @@ void SrsTsContext::set_sync_byte(int8_t sb) srs_error_t SrsTsContext::encode_pat_pmt(SrsFileWriter* writer, int16_t vpid, SrsTsStream vs, int16_t apid, SrsTsStream as) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; if (vs != SrsTsStreamVideoH264 && as != SrsTsStreamAudioAAC && as != SrsTsStreamAudioMp3) { @@ -397,15 +396,12 @@ srs_error_t SrsTsContext::encode_pat_pmt(SrsFileWriter* writer, int16_t vpid, Sr srs_assert(nb_buf < SRS_TS_PACKET_SIZE); memset(buf + nb_buf, 0xFF, SRS_TS_PACKET_SIZE - nb_buf); - SrsBuffer stream; - if ((ret = stream.initialize(buf, nb_buf)) != ERROR_SUCCESS) { - return srs_error_new(ret, "ts: init stream"); - } + SrsBuffer stream(buf, nb_buf); if ((err = pkt->encode(&stream)) != srs_success) { return srs_error_wrap(err, "ts: encode packet"); } - if ((ret = writer->write(buf, SRS_TS_PACKET_SIZE, NULL)) != ERROR_SUCCESS) { - return srs_error_new(ret, "ts: write packet"); + if ((err = writer->write(buf, SRS_TS_PACKET_SIZE, NULL)) != srs_success) { + return srs_error_wrap(err, "ts: write packet"); } } if (true) { @@ -422,15 +418,12 @@ srs_error_t SrsTsContext::encode_pat_pmt(SrsFileWriter* writer, int16_t vpid, Sr srs_assert(nb_buf < SRS_TS_PACKET_SIZE); memset(buf + nb_buf, 0xFF, SRS_TS_PACKET_SIZE - nb_buf); - SrsBuffer stream; - if ((ret = stream.initialize(buf, nb_buf)) != ERROR_SUCCESS) { - return srs_error_new(ret, "ts: init stream"); - } + SrsBuffer stream(buf, nb_buf); if ((err = pkt->encode(&stream)) != srs_success) { return srs_error_wrap(err, "ts: encode packet"); } - if ((ret = writer->write(buf, SRS_TS_PACKET_SIZE, NULL)) != ERROR_SUCCESS) { - return srs_error_new(ret, "ts: write packet"); + if ((err = writer->write(buf, SRS_TS_PACKET_SIZE, NULL)) != srs_success) { + return srs_error_wrap(err, "ts: write packet"); } } @@ -442,7 +435,6 @@ srs_error_t SrsTsContext::encode_pat_pmt(SrsFileWriter* writer, int16_t vpid, Sr srs_error_t SrsTsContext::encode_pes(SrsFileWriter* writer, SrsTsMessage* msg, int16_t pid, SrsTsStream sid, bool pure_audio) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; // Sometimes, the context is not ready(PAT/PMT write failed), error in this situation. @@ -529,15 +521,12 @@ srs_error_t SrsTsContext::encode_pes(SrsFileWriter* writer, SrsTsMessage* msg, i memcpy(buf + nb_buf, p, left); p += left; - SrsBuffer stream; - if ((ret = stream.initialize(buf, nb_buf)) != ERROR_SUCCESS) { - return srs_error_new(ret, "ts: init stream"); - } + SrsBuffer stream(buf, nb_buf); if ((err = pkt->encode(&stream)) != srs_success) { return srs_error_wrap(err, "ts: encode packet"); } - if ((ret = writer->write(buf, SRS_TS_PACKET_SIZE, NULL)) != ERROR_SUCCESS) { - return srs_error_new(ret, "ts: write packet"); + if ((err = writer->write(buf, SRS_TS_PACKET_SIZE, NULL)) != srs_success) { + return srs_error_wrap(err, "ts: write packet"); } } @@ -2562,7 +2551,6 @@ SrsTsContextWriter::~SrsTsContextWriter() srs_error_t SrsTsContextWriter::open(string p) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; path = p; @@ -2572,8 +2560,8 @@ srs_error_t SrsTsContextWriter::open(string p) // reset the context for a new ts start. context->reset(); - if ((ret = writer->open(path)) != ERROR_SUCCESS) { - return srs_error_new(ret, "ts: open writer"); + if ((err = writer->open(path)) != srs_success) { + return srs_error_wrap(err, "ts: open writer"); } return err; diff --git a/trunk/src/kernel/srs_kernel_utility.cpp b/trunk/src/kernel/srs_kernel_utility.cpp index 0ac2233cf..3d5bb364b 100644 --- a/trunk/src/kernel/srs_kernel_utility.cpp +++ b/trunk/src/kernel/srs_kernel_utility.cpp @@ -49,12 +49,12 @@ using namespace std; // @see SRS_SYS_TIME_RESOLUTION_MS_TIMES #define SYS_TIME_RESOLUTION_US 300*1000 -int srs_avc_nalu_read_uev(SrsBitBuffer* stream, int32_t& v) +srs_error_t srs_avc_nalu_read_uev(SrsBitBuffer* stream, int32_t& v) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (stream->empty()) { - return ERROR_AVC_NALU_UEV; + return srs_error_new(ERROR_AVC_NALU_UEV, "empty stream"); } // ue(v) in 9.1 Parsing process for Exp-Golomb codes @@ -71,7 +71,7 @@ int srs_avc_nalu_read_uev(SrsBitBuffer* stream, int32_t& v) } if (leadingZeroBits >= 31) { - return ERROR_AVC_NALU_UEV; + return srs_error_new(ERROR_AVC_NALU_UEV, "%dbits overflow 31bits", leadingZeroBits); } v = (1 << leadingZeroBits) - 1; @@ -80,20 +80,20 @@ int srs_avc_nalu_read_uev(SrsBitBuffer* stream, int32_t& v) v += b << (leadingZeroBits - 1 - i); } - return ret; + return err; } -int srs_avc_nalu_read_bit(SrsBitBuffer* stream, int8_t& v) +srs_error_t srs_avc_nalu_read_bit(SrsBitBuffer* stream, int8_t& v) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; if (stream->empty()) { - return ERROR_AVC_NALU_UEV; + return srs_error_new(ERROR_AVC_NALU_UEV, "empty stream"); } v = stream->read_bit(); - return ret; + return err; } static int64_t _srs_system_time_us_cache = 0; @@ -961,7 +961,7 @@ int srs_do_create_dir_recursively(string dir) *dst++ = v >> 4; out1: out0: - return bits & 1 ? -1 : dst - out; + return bits & 1 ? -1 : (int)(dst - out); } /***************************************************************************** diff --git a/trunk/src/kernel/srs_kernel_utility.hpp b/trunk/src/kernel/srs_kernel_utility.hpp index 130e4e3a3..b021517c4 100644 --- a/trunk/src/kernel/srs_kernel_utility.hpp +++ b/trunk/src/kernel/srs_kernel_utility.hpp @@ -37,8 +37,8 @@ class SrsBitBuffer; #define srs_max(a, b) (((a) < (b))? (b) : (a)) // read nalu uev. -extern int srs_avc_nalu_read_uev(SrsBitBuffer* stream, int32_t& v); -extern int srs_avc_nalu_read_bit(SrsBitBuffer* stream, int8_t& v); +extern srs_error_t srs_avc_nalu_read_uev(SrsBitBuffer* stream, int32_t& v); +extern srs_error_t srs_avc_nalu_read_bit(SrsBitBuffer* stream, int8_t& v); // get current system time in ms, use cache to avoid performance problem extern int64_t srs_get_system_time_ms(); diff --git a/trunk/src/protocol/srs_http_stack.cpp b/trunk/src/protocol/srs_http_stack.cpp index a30129f59..f3052bfaa 100644 --- a/trunk/src/protocol/srs_http_stack.cpp +++ b/trunk/src/protocol/srs_http_stack.cpp @@ -129,16 +129,17 @@ srs_error_t srs_go_http_error(ISrsHttpResponseWriter* w, int code) srs_error_t srs_go_http_error(ISrsHttpResponseWriter* w, int code, string error) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; w->header()->set_content_type("text/plain; charset=utf-8"); w->header()->set_content_length(error.length()); w->write_header(code); - if ((ret = w->write((char*)error.data(), (int)error.length())) != ERROR_SUCCESS) { - return srs_error_new(ret, "http write"); + + if ((err = w->write((char*)error.data(), (int)error.length())) != srs_success) { + return srs_error_wrap(err, "http write"); } - return srs_success; + return err; } SrsHttpHeader::SrsHttpHeader() @@ -330,14 +331,13 @@ srs_error_t SrsHttpFileServer::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMes srs_error_t SrsHttpFileServer::serve_file(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, string fullpath) { - int ret = ERROR_SUCCESS; srs_error_t err = srs_success; // open the target file. SrsFileReader fs; - if ((ret = fs.open(fullpath)) != ERROR_SUCCESS) { - return srs_error_new(ret, "open file %s", fullpath.c_str()); + if ((err = fs.open(fullpath)) != srs_success) { + return srs_error_wrap(err, "open file %s", fullpath.c_str()); } int64_t length = fs.filesize(); @@ -397,8 +397,8 @@ srs_error_t SrsHttpFileServer::serve_file(ISrsHttpResponseWriter* w, ISrsHttpMes return srs_error_wrap(err, "copy file=%s size=%d", fullpath.c_str(), left); } - if ((ret = w->final_request()) != ERROR_SUCCESS) { - return srs_error_new(ret, "final request"); + if ((err = w->final_request()) != srs_success) { + return srs_error_wrap(err, "final request"); } return err; @@ -468,7 +468,7 @@ srs_error_t SrsHttpFileServer::serve_mp4_stream(ISrsHttpResponseWriter* w, ISrsH srs_error_t SrsHttpFileServer::copy(ISrsHttpResponseWriter* w, SrsFileReader* fs, ISrsHttpMessage* r, int size) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; int left = size; char* buf = r->http_ts_send_buffer(); @@ -476,21 +476,21 @@ srs_error_t SrsHttpFileServer::copy(ISrsHttpResponseWriter* w, SrsFileReader* fs while (left > 0) { ssize_t nread = -1; int max_read = srs_min(left, SRS_HTTP_TS_SEND_BUFFER_SIZE); - if ((ret = fs->read(buf, max_read, &nread)) != ERROR_SUCCESS) { + if ((err = fs->read(buf, max_read, &nread)) != srs_success) { break; } left -= nread; - if ((ret = w->write(buf, (int)nread)) != ERROR_SUCCESS) { + if ((err = w->write(buf, (int)nread)) != srs_success) { break; } } - if (ret != ERROR_SUCCESS) { - return srs_error_new(ret, "copy"); + if (err != srs_success) { + return srs_error_wrap(err, "copy"); } - return srs_success; + return err; } SrsHttpMuxEntry::SrsHttpMuxEntry() @@ -765,7 +765,7 @@ srs_error_t SrsHttpCorsMux::initialize(ISrsHttpServeMux* worker, bool cros_enabl srs_error_t SrsHttpCorsMux::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) { - int ret = ERROR_SUCCESS; + srs_error_t err = srs_success; // If CORS enabled, and there is a "Origin" header, it's CORS. if (enabled) { @@ -795,8 +795,8 @@ srs_error_t SrsHttpCorsMux::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessag } else { w->write_header(SRS_CONSTS_HTTP_MethodNotAllowed); } - if ((ret = w->final_request()) != ERROR_SUCCESS) { - return srs_error_new(ret, "final request"); + if ((err = w->final_request()) != srs_success) { + return srs_error_wrap(err, "final request"); } } diff --git a/trunk/src/protocol/srs_http_stack.hpp b/trunk/src/protocol/srs_http_stack.hpp index 56dce170a..2ad7144bc 100644 --- a/trunk/src/protocol/srs_http_stack.hpp +++ b/trunk/src/protocol/srs_http_stack.hpp @@ -180,7 +180,7 @@ public: // final the request to complete the chunked encoding. // for no-chunked mode, // final to send request, for example, content-length is 0. - virtual int final_request() = 0; + virtual srs_error_t final_request() = 0; // Header returns the header map that will be sent by WriteHeader. // Changing the header after a call to WriteHeader (or Write) has @@ -193,12 +193,12 @@ public: // Content-Type line, Write adds a Content-Type set to the result of passing // the initial 512 bytes of written data to DetectContentType. // @param data, the data to send. NULL to flush header only. - virtual int write(char* data, int size) = 0; + virtual srs_error_t write(char* data, int size) = 0; /** * for the HTTP FLV, to writev to improve performance. * @see https://github.com/ossrs/srs/issues/405 */ - virtual int writev(const iovec* iov, int iovcnt, ssize_t* pnwrite) = 0; + virtual srs_error_t writev(const iovec* iov, int iovcnt, ssize_t* pnwrite) = 0; // WriteHeader sends an HTTP response header with status code. // If WriteHeader is not called explicitly, the first call to Write @@ -235,7 +235,7 @@ public: * or by chunked), because the sdk never know whether there is no data or * infinite chunked. */ - virtual int read(char* data, int nb_data, int* nb_read) = 0; + virtual srs_error_t read(char* data, int nb_data, int* nb_read) = 0; }; // Objects implementing the Handler interface can be @@ -538,12 +538,12 @@ public: * which is chunked encoding without chunked header. * @remark error when message is in chunked or content-length specified. */ - virtual int enter_infinite_chunked() = 0; + virtual srs_error_t enter_infinite_chunked() = 0; /** * read body to string. * @remark for small http body. */ - virtual int body_read_all(std::string& body) = 0; + virtual srs_error_t body_read_all(std::string& body) = 0; /** * get the body reader, to read one by one. * @remark when body is very large, or chunked, use this. diff --git a/trunk/src/protocol/srs_kafka_stack.cpp b/trunk/src/protocol/srs_kafka_stack.cpp index 923375562..220dd595c 100644 --- a/trunk/src/protocol/srs_kafka_stack.cpp +++ b/trunk/src/protocol/srs_kafka_stack.cpp @@ -1104,7 +1104,7 @@ int SrsKafkaProducerPartitionMessages::decode(SrsBuffer* buf) // for the message set decode util empty, we must create a new buffer when // there exists other objects after message set. - if (buf->size() - buf->pos() != message_set_size) { + if (buf->left() != message_set_size) { SrsBuffer* tbuf = new SrsBuffer(); SrsAutoFree(SrsBuffer, tbuf);