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

For #913, Kernel MP4 FLV HTTP support complex error.

Browse source
This commit is contained in:
winlin 2017-12-31 12:11:48 +08:00
parent 9802dc326e
commit 204ef041da
23 changed files with 1413 additions and 1660 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -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");
}
int 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;
return err;
}
int SrsTsStreamEncoder::write_metadata(int64_t /*timestamp*/, char* /*data*/, int /*size*/)
srs_error_t SrsTsStreamEncoder::write_video(int64_t timestamp, char* data, int size)
{
return ERROR_SUCCESS;
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;
}
srs_error_t SrsTsStreamEncoder::write_metadata(int64_t /*timestamp*/, char* /*data*/, int /*size*/)
{
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;
}
int SrsHttpStreamServer::initialize_flv_entry(std::string vhost)
return err;
}
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;
}

72
trunk/src/app/srs_app_http_stream.hpp
View file

@ -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

55
trunk/src/kernel/srs_kernel_aac.cpp
View file

@ -39,55 +39,48 @@ using namespace std;
#include <srs_kernel_buffer.hpp>
#include <srs_kernel_file.hpp>
#include <srs_kernel_codec.hpp>
#include <srs_core_autofree.hpp>
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

6
trunk/src/kernel/srs_kernel_aac.hpp
View file

@ -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

45
trunk/src/kernel/srs_kernel_buffer.cpp
View file

@ -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() {

20
trunk/src/kernel/srs_kernel_buffer.hpp
View file

@ -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,18 +97,6 @@ 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
public:
/**
@ -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();
};

117
trunk/src/kernel/srs_kernel_codec.cpp
View file

@ -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.

2
trunk/src/kernel/srs_kernel_codec.hpp
View file

@ -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.

95
trunk/src/kernel/srs_kernel_file.cpp
View file

@ -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;
}

16
trunk/src/kernel/srs_kernel_file.hpp
View file

@ -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

330
trunk/src/kernel/srs_kernel_flv.cpp
View file

@ -39,6 +39,7 @@ using namespace std;
#include <srs_kernel_codec.hpp>
#include <srs_kernel_utility.hpp>
#include <srs_core_mem_watch.hpp>
#include <srs_core_autofree.hpp>
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<SrsFileReader*>(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;
}

53
trunk/src/kernel/srs_kernel_flv.hpp
View file

@ -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

8
trunk/src/kernel/srs_kernel_io.hpp
View file

@ -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;
};
/**

52
trunk/src/kernel/srs_kernel_mp3.cpp
View file

@ -39,37 +39,36 @@ using namespace std;
#include <srs_kernel_buffer.hpp>
#include <srs_kernel_file.hpp>
#include <srs_kernel_codec.hpp>
#include <srs_core_autofree.hpp>
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");
}
int SrsMp3Transmuxer::write_audio(int64_t timestamp, char* data, int size)
return err;
}
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");
}
return writer->write(data + stream->pos(), size - stream->pos(), NULL);
if ((err = writer->write(data + stream->pos(), size - stream->pos(), NULL)) != srs_success) {
return srs_error_wrap(err, "write audio");
}
return err;
}
#endif

8
trunk/src/kernel/srs_kernel_mp3.hpp
View file

@ -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

1599
trunk/src/kernel/srs_kernel_mp4.cpp
View file

File diff suppressed because it is too large Load diff

247
trunk/src/kernel/srs_kernel_mp4.hpp
View file

@ -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<uint64_t, SrsMp4Sample*>& tses, SrsMp4MovieBox* moov);
virtual srs_error_t do_load(std::map<uint64_t, SrsMp4Sample*>& 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<uint64_t, SrsMp4Sample*>& tses, SrsFrameType tt,
virtual srs_error_t load_trak(std::map<uint64_t, SrsMp4Sample*>& 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

34
trunk/src/kernel/srs_kernel_ts.cpp
View file

@ -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;

20
trunk/src/kernel/srs_kernel_utility.cpp
View file

@ -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);
}
/*****************************************************************************

4
trunk/src/kernel/srs_kernel_utility.hpp
View file

@ -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();

36
trunk/src/protocol/srs_http_stack.cpp
View file

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

12
trunk/src/protocol/srs_http_stack.hpp
View file

@ -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.

2
trunk/src/protocol/srs_kafka_stack.cpp
View file

@ -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);