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

trunk/src/kernel/srs_kernel_flv.cpp

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