finish kernel utest. to 0.9.149

trunk/src/app/srs_app_avc_aac.cpp

@@ -204,11 +204,11 @@ int SrsAvcAacCodec::audio_aac_demux(int8_t* data, int size, SrsCodecSample* samp
     if (aac_packet_type == SrsCodecAudioTypeSequenceHeader) {
         // AudioSpecificConfig
         // 1.6.2.1 AudioSpecificConfig, in aac-mp4a-format-ISO_IEC_14496-3+2001.pdf, page 33.
-        aac_extra_size = stream->left();
+        aac_extra_size = stream->size() - stream->pos();
         if (aac_extra_size > 0) {
             srs_freep(aac_extra_data);
             aac_extra_data = new char[aac_extra_size];
-            memcpy(aac_extra_data, stream->current(), aac_extra_size);
+            memcpy(aac_extra_data, stream->data() + stream->pos(), aac_extra_size);
         }
         
         // only need to decode the first 2bytes:
@@ -253,7 +253,7 @@ int SrsAvcAacCodec::audio_aac_demux(int8_t* data, int size, SrsCodecSample* samp
         
         // Raw AAC frame data in UI8 []
         // 6.3 Raw Data, aac-iso-13818-7.pdf, page 28
-        if ((ret = sample->add_sample(stream->current(), stream->left())) != ERROR_SUCCESS) {
+        if ((ret = sample->add_sample(stream->data() + stream->pos(), stream->size() - stream->pos())) != ERROR_SUCCESS) {
             srs_error("hls add audio sample failed. ret=%d", ret);
             return ret;
         }
@@ -318,11 +318,11 @@ int SrsAvcAacCodec::video_avc_demux(int8_t* data, int size, SrsCodecSample* samp
     if (avc_packet_type == SrsCodecVideoAVCTypeSequenceHeader) {
         // AVCDecoderConfigurationRecord
         // 5.2.4.1.1 Syntax, H.264-AVC-ISO_IEC_14496-15.pdf, page 16
-        avc_extra_size = stream->left();
+        avc_extra_size = stream->size() - stream->pos();
         if (avc_extra_size > 0) {
             srs_freep(avc_extra_data);
             avc_extra_data = new char[avc_extra_size];
-            memcpy(avc_extra_data, stream->current(), avc_extra_size);
+            memcpy(avc_extra_data, stream->data() + stream->pos(), avc_extra_size);
         }
         
         if (!stream->require(6)) {
@@ -367,7 +367,7 @@ int SrsAvcAacCodec::video_avc_demux(int8_t* data, int size, SrsCodecSample* samp
         if (sequenceParameterSetLength > 0) {
             srs_freep(sequenceParameterSetNALUnit);
             sequenceParameterSetNALUnit = new char[sequenceParameterSetLength];
-            memcpy(sequenceParameterSetNALUnit, stream->current(), sequenceParameterSetLength);
+            memcpy(sequenceParameterSetNALUnit, stream->data() + stream->pos(), sequenceParameterSetLength);
             stream->skip(sequenceParameterSetLength);
         }
         // 1 pps
@@ -397,7 +397,7 @@ int SrsAvcAacCodec::video_avc_demux(int8_t* data, int size, SrsCodecSample* samp
         if (pictureParameterSetLength > 0) {
             srs_freep(pictureParameterSetNALUnit);
             pictureParameterSetNALUnit = new char[pictureParameterSetLength];
-            memcpy(pictureParameterSetNALUnit, stream->current(), pictureParameterSetLength);
+            memcpy(pictureParameterSetNALUnit, stream->data() + stream->pos(), pictureParameterSetLength);
             stream->skip(pictureParameterSetLength);
         }
     } else if (avc_packet_type == SrsCodecVideoAVCTypeNALU){
@@ -410,7 +410,7 @@ int SrsAvcAacCodec::video_avc_demux(int8_t* data, int size, SrsCodecSample* samp
         
         // One or more NALUs (Full frames are required)
         // 5.3.4.2.1 Syntax, H.264-AVC-ISO_IEC_14496-15.pdf, page 20
-        int PictureLength = stream->left();
+        int PictureLength = stream->size() - stream->pos();
         for (int i = 0; i < PictureLength;) {
             if (!stream->require(NAL_unit_length + 1)) {
                 ret = ERROR_HLS_DECODE_ERROR;
@@ -434,7 +434,7 @@ int SrsAvcAacCodec::video_avc_demux(int8_t* data, int size, SrsCodecSample* samp
                 return ret;
             }
             // 7.3.1 NAL unit syntax, H.264-AVC-ISO_IEC_14496-10.pdf, page 44.
-            if ((ret = sample->add_sample(stream->current(), NALUnitLength)) != ERROR_SUCCESS) {
+            if ((ret = sample->add_sample(stream->data() + stream->pos(), NALUnitLength)) != ERROR_SUCCESS) {
                 srs_error("hls add video sample failed. ret=%d", ret);
                 return ret;
             }

trunk/src/core/srs_core.hpp

@@ -31,7 +31,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // current release version
 #define VERSION_MAJOR "0"
 #define VERSION_MINOR "9"
-#define VERSION_REVISION "148"
+#define VERSION_REVISION "149"
 #define RTMP_SIG_SRS_VERSION VERSION_MAJOR"."VERSION_MINOR"."VERSION_REVISION
 // server info.
 #define RTMP_SIG_SRS_KEY "SRS"

trunk/src/kernel/srs_kernel_error.hpp

@@ -87,7 +87,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // aggregate message parse failed.
 #define ERROR_RTMP_AGGREGATE                324
 
-#define ERROR_SYSTEM_STREAM_INIT            400
 #define ERROR_SYSTEM_PACKET_INVALID         401
 #define ERROR_SYSTEM_CLIENT_INVALID         402
 #define ERROR_SYSTEM_ASSERT_FAILED          403
@@ -190,6 +189,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #define ERROR_KERNEL_FLV_HEADER             900
 #define ERROR_KERNEL_FLV_STREAM_CLOSED      901
+#define ERROR_KERNEL_STREAM_INIT            902
 
 // system control message, 
 // not an error, but special control logic.

trunk/src/kernel/srs_kernel_stream.cpp

@@ -31,8 +31,8 @@ using namespace std;
 
 SrsStream::SrsStream()
 {
-    p = bytes = NULL;
+    p = _bytes = NULL;
-    size = 0;
+    _size = 0;
     
     // TODO: support both little and big endian.
     srs_assert(srs_is_little_endian());
@@ -42,61 +42,61 @@ SrsStream::~SrsStream()
 {
 }
 
-int SrsStream::initialize(char* _bytes, int _size)
+int SrsStream::initialize(char* bytes, int size)
 {
     int ret = ERROR_SUCCESS;
     
-    if (!_bytes) {
+    if (!bytes) {
-        ret = ERROR_SYSTEM_STREAM_INIT;
+        ret = ERROR_KERNEL_STREAM_INIT;
         srs_error("stream param bytes must not be NULL. ret=%d", ret);
         return ret;
     }
     
-    if (_size <= 0) {
+    if (size <= 0) {
-        ret = ERROR_SYSTEM_STREAM_INIT;
+        ret = ERROR_KERNEL_STREAM_INIT;
         srs_error("stream param size must be positive. ret=%d", ret);
         return ret;
     }
 
-    size = _size;
+    _size = size;
-    p = bytes = _bytes;
+    p = _bytes = bytes;
+    srs_info("init stream ok, size=%d", size);
 
     return ret;
 }
 
-void SrsStream::reset()
+char* SrsStream::data()
 {
-    p = bytes;
+    return _bytes;
 }
 
-bool SrsStream::empty()
+int SrsStream::size()
 {
-    return !p || !bytes || (p >= bytes + size);
+    return _size;
 }
 
-bool SrsStream::require(int required_size)
+int SrsStream::pos()
 {
-    return !empty() && (required_size <= bytes + size - p);
+    return p - _bytes;
 }
 
-void SrsStream::skip(int size)
+bool SrsStream::empty()
 {
-    p += size;
+    return !_bytes || (p >= _bytes + _size);
 }
 
-int SrsStream::pos()
+bool SrsStream::require(int required_size)
 {
-    return p - bytes;
+    srs_assert(required_size > 0);
-}
     
-int SrsStream::left()
+    return required_size <= _size - (p - _bytes);
-{
-    return size - pos();
 }
 
-char* SrsStream::current()
+void SrsStream::skip(int size)
 {
-    return p;
+    srs_assert(p);
+    
+    p += size;
 }
 
 int8_t SrsStream::read_1bytes()

trunk/src/kernel/srs_kernel_stream.hpp

@@ -33,52 +33,67 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <sys/types.h>
 #include <string>
 
+/**
+* bytes utility, used to:
+* convert basic types to bytes,
+* build basic types from bytes.
+*/
 class SrsStream
 {
 private:
     char* p;
     char* pp;
-    char* bytes;
+    char* _bytes;
-    int size;
+    int _size;
 public:
     SrsStream();
     virtual ~SrsStream();
 public:
     /**
     * initialize the stream from bytes.
-    * @_bytes, must not be NULL, or return error.
+    * @bytes, the bytes to convert from/to basic types.
-    * @_size, must be positive, or return error.
+    * @size, the size of bytes.
-    * @remark, stream never free the _bytes, user must free it.
+    * @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* bytes, int size);
+// get the status of stream
+public:
+    /**
+    * get data of stream, set by initialize.
+    * current bytes = data() + pos()
     */
-    virtual int initialize(char* _bytes, int _size);
+    virtual char* data();
     /**
-    * reset the position to beginning.
+    * the total stream size, set by initialize.
+    * left bytes = size() - pos().
     */
-    virtual void reset();
+    virtual int size();
+    /**
+    * tell the current pos.
+    */
+    virtual int pos();
     /**
     * whether stream is empty.
-    * if empty, never read or write.
+    * if empty, user should never read or write.
     */
     virtual bool empty();
     /**
     * whether required size is ok.
     * @return true if stream can read/write specified required_size bytes.
+    * @remark assert required_size positive.
     */
     virtual bool require(int required_size);
+// to change stream.
+public:
     /**
     * to skip some size.
-    * @size can be any value. positive to forward; nagetive to backward.
+    * @param size can be any value. positive to forward; nagetive to backward.
+    * @remark to skip(pos()) to reset stream.
+    * @remark assert initialized, the data() not NULL.
     */
     virtual void skip(int size);
-    /**
-    * tell the current pos.
-    */
-    virtual int pos();
-    /**
-    * left size of bytes.
-    */
-    virtual int left();
-    virtual char* current();
 public:
     /**
     * get 1bytes char from stream.

trunk/src/libs/srs_librtmp.cpp

@@ -659,7 +659,7 @@ srs_amf0_t srs_amf0_parse(char* data, int size, int* nparsed)
         return amf0;
     }
     
-    stream.reset();
+    stream.skip(-1 * stream.pos());
     if ((ret = any->read(&stream)) != ERROR_SUCCESS) {
         srs_freep(any);
         return amf0;

trunk/src/rtmp/srs_protocol_rtmp_stack.cpp

@@ -601,7 +601,7 @@ int SrsProtocol::do_decode_message(SrsMessageHeader& header, SrsStream* stream,
             srs_verbose("AMF0/AMF3 command id, transcationId=%.2f", transactionId);
             
             // reset stream, for header read completed.
-            stream->reset();
+            stream->skip(-1 * stream->pos());
             if (header.is_amf3_command()) {
                 stream->skip(1);
             }
@@ -638,7 +638,7 @@ int SrsProtocol::do_decode_message(SrsMessageHeader& header, SrsStream* stream,
         }
         
         // reset to zero(amf3 to 1) to restart decode.
-        stream->reset();
+        stream->skip(-1 * stream->pos());
         if (header.is_amf3_command()) {
             stream->skip(1);
         }

trunk/src/utest/srs_utest_amf0.cpp

@@ -521,8 +521,8 @@ VOID TEST(AMF0Test, ApiAnyIO)
     
     // object eof
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
-        s.current()[2] = 0x09;
+        (s.data() + s.pos())[2] = 0x09;
         
         o = SrsAmf0Any::object_eof();
         SrsAutoFree(SrsAmf0Any, o);
@@ -531,12 +531,12 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(o->total_size(), s.pos());
         EXPECT_EQ(3, s.pos());
         
-        s.reset();
+        s.skip(-1 * s.pos());
-        s.current()[0] = 0x01;
+        (s.data() + s.pos())[0] = 0x01;
         EXPECT_NE(ERROR_SUCCESS, o->read(&s));
     }
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::object_eof();
         SrsAutoFree(SrsAmf0Any, o);
@@ -551,7 +551,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
     
     // string
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::str("winlin");
         SrsAutoFree(SrsAmf0Any, o);
@@ -559,14 +559,14 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(o->total_size(), s.pos());
         
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(2, s.read_1bytes());
         EXPECT_EQ(6, s.read_2bytes());
-        EXPECT_EQ('w', s.current()[0]);
+        EXPECT_EQ('w', (s.data() + s.pos())[0]);
-        EXPECT_EQ('n', s.current()[5]);
+        EXPECT_EQ('n', (s.data() + s.pos())[5]);
         
-        s.reset();
+        s.skip(-1 * s.pos());
-        s.current()[3] = 'x';
+        (s.data() + s.pos())[3] = 'x';
         EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
         EXPECT_EQ(o->total_size(), s.pos());
         EXPECT_STREQ("xinlin", o->to_str().c_str());
@@ -574,7 +574,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
     
     // number
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::number(10);
         SrsAutoFree(SrsAmf0Any, o);
@@ -582,10 +582,10 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(o->total_size(), s.pos());
 
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(0, s.read_1bytes());
         
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
         EXPECT_EQ(o->total_size(), s.pos());
         EXPECT_DOUBLE_EQ(10, o->to_number());
@@ -593,7 +593,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
     
     // boolean
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::boolean(true);
         SrsAutoFree(SrsAmf0Any, o);
@@ -601,16 +601,16 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(o->total_size(), s.pos());
 
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(1, s.read_1bytes());
         
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
         EXPECT_EQ(o->total_size(), s.pos());
         EXPECT_TRUE(o->to_boolean());
     }
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::boolean(false);
         SrsAutoFree(SrsAmf0Any, o);
@@ -618,10 +618,10 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(o->total_size(), s.pos());
 
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(1, s.read_1bytes());
         
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
         EXPECT_EQ(o->total_size(), s.pos());
         EXPECT_FALSE(o->to_boolean());
@@ -629,7 +629,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
     
     // null
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::null();
         SrsAutoFree(SrsAmf0Any, o);
@@ -637,10 +637,10 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(o->total_size(), s.pos());
 
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(5, s.read_1bytes());
         
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
         EXPECT_EQ(o->total_size(), s.pos());
         EXPECT_TRUE(o->is_null());
@@ -648,7 +648,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
     
     // undefined
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::undefined();
         SrsAutoFree(SrsAmf0Any, o);
@@ -656,10 +656,10 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(o->total_size(), s.pos());
 
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(6, s.read_1bytes());
         
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
         EXPECT_EQ(o->total_size(), s.pos());
         EXPECT_TRUE(o->is_undefined());
@@ -667,7 +667,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
 
     // any: string
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::str("winlin");
         SrsAutoFree(SrsAmf0Any, o);
@@ -675,7 +675,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(o->total_size(), s.pos());
 
-        s.reset();
+        s.skip(-1 * s.pos());
         
         SrsAmf0Any* po = NULL;
         EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
@@ -687,7 +687,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
 
     // any: number
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::number(10);
         SrsAutoFree(SrsAmf0Any, o);
@@ -695,7 +695,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(o->total_size(), s.pos());
 
-        s.reset();
+        s.skip(-1 * s.pos());
         
         SrsAmf0Any* po = NULL;
         EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
@@ -707,7 +707,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
 
     // any: boolean
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::boolean(true);
         SrsAutoFree(SrsAmf0Any, o);
@@ -715,7 +715,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(o->total_size(), s.pos());
 
-        s.reset();
+        s.skip(-1 * s.pos());
         
         SrsAmf0Any* po = NULL;
         EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
@@ -727,7 +727,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
 
     // any: null
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::null();
         SrsAutoFree(SrsAmf0Any, o);
@@ -735,7 +735,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(o->total_size(), s.pos());
 
-        s.reset();
+        s.skip(-1 * s.pos());
         
         SrsAmf0Any* po = NULL;
         EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
@@ -746,7 +746,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
 
     // any: undefined
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::undefined();
         SrsAutoFree(SrsAmf0Any, o);
@@ -754,7 +754,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(o->total_size(), s.pos());
 
-        s.reset();
+        s.skip(-1 * s.pos());
         
         SrsAmf0Any* po = NULL;
         EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
@@ -765,7 +765,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
     
     // mixed any
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
         
         o = SrsAmf0Any::str("winlin");
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
@@ -787,7 +787,7 @@ VOID TEST(AMF0Test, ApiAnyIO)
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         srs_freep(o);
         
-        s.reset();
+        s.skip(-1 * s.pos());
         SrsAmf0Any* po = NULL;
         
         EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
@@ -831,8 +831,8 @@ VOID TEST(AMF0Test, ApiAnyAssert)
     
     // read any
     if (true) {
-        s.reset();
+        s.skip(-1 * s.pos());
-        s.current()[0] = 0x12;
+        (s.data() + s.pos())[0] = 0x12;
         EXPECT_NE(ERROR_SUCCESS, srs_amf0_read_any(&s, &o));
         EXPECT_TRUE(NULL == o);
         srs_freep(o);
@@ -884,7 +884,7 @@ VOID TEST(AMF0Test, ApiAnyAssert)
     if (true) {
         o = SrsAmf0Any::object();
         SrsAutoFree(SrsAmf0Any, o);
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(1+3, s.pos());
     }
@@ -893,7 +893,7 @@ VOID TEST(AMF0Test, ApiAnyAssert)
     if (true) {
         o = SrsAmf0Any::ecma_array();
         SrsAutoFree(SrsAmf0Any, o);
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(1+4+3, s.pos());
     }
@@ -902,7 +902,7 @@ VOID TEST(AMF0Test, ApiAnyAssert)
     if (true) {
         o = SrsAmf0Any::strict_array();
         SrsAutoFree(SrsAmf0Any, o);
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(1+4, s.pos());
     }
@@ -1111,11 +1111,11 @@ VOID TEST(AMF0Test, ApiStrictArray)
         o = SrsAmf0Any::strict_array();
         SrsAutoFree(SrsAmf0StrictArray, o);
         
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(5, s.pos());
         
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(0x0a, s.read_1bytes());
         EXPECT_EQ(0x00, s.read_4bytes());
     }
@@ -1126,7 +1126,7 @@ VOID TEST(AMF0Test, ApiStrictArray)
         
         o->append(SrsAmf0Any::number(0));
         
-        s.reset();
+        s.skip(-1 * s.pos());
         EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
         EXPECT_EQ(5 + SrsAmf0Size::number(), s.pos());
     }

trunk/src/utest/srs_utest_kernel.cpp

@@ -29,6 +29,7 @@ using namespace std;
 #include <srs_kernel_flv.hpp>
 #include <srs_kernel_utility.hpp>
 #include <srs_protocol_utility.hpp>
+#include <srs_kernel_stream.hpp>
 
 #define MAX_MOCK_DATA_SIZE 1024 * 1024
 
@@ -198,7 +199,7 @@ int MockBufferReader::read(void* buf, size_t size, ssize_t* nread)
     return ERROR_SUCCESS;
 }
 
-VOID TEST(BufferTest, DefaultObject)
+VOID TEST(KernelBufferTest, DefaultObject)
 {
     SrsBuffer b;
     
@@ -206,7 +207,7 @@ VOID TEST(BufferTest, DefaultObject)
     EXPECT_EQ(NULL, b.bytes());
 }
 
-VOID TEST(BufferTest, AppendBytes)
+VOID TEST(KernelBufferTest, AppendBytes)
 {
     SrsBuffer b;
     
@@ -226,7 +227,7 @@ VOID TEST(BufferTest, AppendBytes)
     EXPECT_EQ('n', b.bytes()[11]);
 }
 
-VOID TEST(BufferTest, EraseBytes)
+VOID TEST(KernelBufferTest, EraseBytes)
 {
     SrsBuffer b;
     
@@ -262,7 +263,7 @@ VOID TEST(BufferTest, EraseBytes)
     EXPECT_EQ(0, b.length());
 }
 
-VOID TEST(BufferTest, Grow)
+VOID TEST(KernelBufferTest, Grow)
 {
     SrsBuffer b;
     MockBufferReader r("winlin");
@@ -954,3 +955,557 @@ VOID TEST(KernelFlvTest, FlvVSDecoderSeek)
     EXPECT_TRUE(ERROR_SUCCESS == dec.lseek(5));
     EXPECT_TRUE(5 == fs.offset);
 }
+
+/**
+* test the stream utility, bytes from/to basic types.
+*/
+VOID TEST(KernelStreamTest, StreamInitialize)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    EXPECT_TRUE(ERROR_SUCCESS != s.initialize(NULL, 1024));
+    EXPECT_TRUE(ERROR_SUCCESS != s.initialize(data, 0));
+    EXPECT_TRUE(ERROR_SUCCESS != s.initialize(data, -1));
+}
+
+/**
+* test the stream utility, access data
+*/
+VOID TEST(KernelStreamTest, StreamData)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(s.data() == NULL);
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    EXPECT_TRUE(s.data() == data);
+}
+
+/**
+* test the stream utility, access size
+*/
+VOID TEST(KernelStreamTest, StreamSize)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(s.size() == 0);
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    EXPECT_TRUE(s.size() == 1024);
+}
+
+/**
+* test the stream utility, access pos
+*/
+VOID TEST(KernelStreamTest, StreamPos)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(s.pos() == 0);
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    EXPECT_TRUE(s.pos() == 0);
+    
+    s.read_bytes(data, 1024);
+    EXPECT_TRUE(s.pos() == 1024);
+}
+
+/**
+* test the stream utility, access empty
+*/
+VOID TEST(KernelStreamTest, StreamEmpty)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(s.empty());
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    EXPECT_FALSE(s.empty());
+    
+    s.read_bytes(data, 1024);
+    EXPECT_TRUE(s.empty());
+}
+
+/**
+* test the stream utility, access require
+*/
+VOID TEST(KernelStreamTest, StreamRequire)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_FALSE(s.require(1));
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    EXPECT_TRUE(s.require(1));
+    EXPECT_TRUE(s.require(1024));
+    
+    s.read_bytes(data, 1000);
+    EXPECT_TRUE(s.require(1));
+    
+    s.read_bytes(data, 24);
+    EXPECT_FALSE(s.require(1));
+}
+
+/**
+* test the stream utility, skip bytes
+*/
+VOID TEST(KernelStreamTest, StreamSkip)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    EXPECT_EQ(0, s.pos());
+    
+    s.skip(1);
+    EXPECT_EQ(1, s.pos());
+
+    s.skip(-1);
+    EXPECT_EQ(0 , s.pos());
+}
+
+/**
+* test the stream utility, read 1bytes
+*/
+VOID TEST(KernelStreamTest, StreamRead1Bytes)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    
+    data[0] = 0x12;
+    data[99] = 0x13;
+    data[100] = 0x14;
+    data[101] = 0x15;
+    EXPECT_EQ(0x12, s.read_1bytes());
+    
+    s.skip(-1 * s.pos());
+    s.skip(100);
+    EXPECT_EQ(0x14, s.read_1bytes());
+}
+
+/**
+* test the stream utility, read 2bytes
+*/
+VOID TEST(KernelStreamTest, StreamRead2Bytes)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    
+    data[0] = 0x01;
+    data[1] = 0x02;
+    data[2] = 0x03;
+    data[3] = 0x04;
+    data[4] = 0x05;
+    data[5] = 0x06;
+    data[6] = 0x07;
+    data[7] = 0x08;
+    data[8] = 0x09;
+    data[9] = 0x0a;
+    
+    EXPECT_EQ(0x0102, s.read_2bytes());
+    EXPECT_EQ(0x0304, s.read_2bytes());
+
+    s.skip(-1 * s.pos());
+    s.skip(3);
+    EXPECT_EQ(0x0405, s.read_2bytes());
+}
+
+/**
+* test the stream utility, read 3bytes
+*/
+VOID TEST(KernelStreamTest, StreamRead3Bytes)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    
+    data[0] = 0x01;
+    data[1] = 0x02;
+    data[2] = 0x03;
+    data[3] = 0x04;
+    data[4] = 0x05;
+    data[5] = 0x06;
+    data[6] = 0x07;
+    data[7] = 0x08;
+    data[8] = 0x09;
+    data[9] = 0x0a;
+    
+    EXPECT_EQ(0x010203, s.read_3bytes());
+    EXPECT_EQ(0x040506, s.read_3bytes());
+
+    s.skip(-1 * s.pos());
+    s.skip(5);
+    EXPECT_EQ(0x060708, s.read_3bytes());
+}
+
+/**
+* test the stream utility, read 4bytes
+*/
+VOID TEST(KernelStreamTest, StreamRead4Bytes)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    
+    data[0] = 0x01;
+    data[1] = 0x02;
+    data[2] = 0x03;
+    data[3] = 0x04;
+    data[4] = 0x05;
+    data[5] = 0x06;
+    data[6] = 0x07;
+    data[7] = 0x08;
+    data[8] = 0x09;
+    data[9] = 0x0a;
+    
+    EXPECT_EQ(0x01020304, s.read_4bytes());
+    EXPECT_EQ(0x05060708, s.read_4bytes());
+
+    s.skip(-1 * s.pos());
+    s.skip(5);
+    EXPECT_EQ(0x06070809, s.read_4bytes());
+}
+
+/**
+* test the stream utility, read 8bytes
+*/
+VOID TEST(KernelStreamTest, StreamRead8Bytes)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    
+    data[0] = 0x01;
+    data[1] = 0x02;
+    data[2] = 0x03;
+    data[3] = 0x04;
+    data[4] = 0x05;
+    data[5] = 0x06;
+    data[6] = 0x07;
+    data[7] = 0x08;
+    data[8] = 0x09;
+    data[9] = 0x0a;
+    data[10] = 0x0b;
+    data[11] = 0x0c;
+    data[12] = 0x0d;
+    data[13] = 0x0e;
+    data[14] = 0x0f;
+    data[15] = 0x10;
+    data[16] = 0x11;
+    data[17] = 0x12;
+    data[18] = 0x13;
+    data[19] = 0x14;
+    
+    EXPECT_EQ(0x0102030405060708, s.read_8bytes());
+    EXPECT_EQ(0x090a0b0c0d0e0f10, s.read_8bytes());
+
+    s.skip(-1 * s.pos());
+    s.skip(5);
+    EXPECT_EQ(0x060708090a0b0c0d, s.read_8bytes());
+}
+
+/**
+* test the stream utility, read string
+*/
+VOID TEST(KernelStreamTest, StreamReadString)
+{
+    SrsStream s;
+    char data[] = "Hello, world!";
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, sizeof(data) - 1));
+    
+    string str = s.read_string(2);
+    EXPECT_STREQ("He", str.c_str());
+    
+    str = s.read_string(2);
+    EXPECT_STREQ("ll", str.c_str());
+    
+    s.skip(3);
+    str = s.read_string(6);
+    EXPECT_STREQ("world!", str.c_str());
+    
+    EXPECT_TRUE(s.empty());
+}
+
+/**
+* test the stream utility, read bytes
+*/
+VOID TEST(KernelStreamTest, StreamReadBytes)
+{
+    SrsStream s;
+    char data[] = "Hello, world!";
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, sizeof(data) - 1));
+    
+    char bytes[64];
+    s.read_bytes(bytes, 2);
+    bytes[2] = 0;
+    EXPECT_STREQ("He", bytes);
+    
+    s.read_bytes(bytes, 2);
+    bytes[2] = 0;
+    EXPECT_STREQ("ll", bytes);
+    
+    s.skip(3);
+    s.read_bytes(bytes, 6);
+    bytes[6] = 0;
+    EXPECT_STREQ("world!", bytes);
+    
+    EXPECT_TRUE(s.empty());
+}
+
+/**
+* test the stream utility, write 1bytes
+*/
+VOID TEST(KernelStreamTest, StreamWrite1Bytes)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    
+    s.write_1bytes(0x10);
+    s.write_1bytes(0x11);
+    s.write_1bytes(0x12);
+    s.write_1bytes(0x13);
+
+    s.skip(-1 * s.pos());
+    EXPECT_EQ(0x10, s.read_1bytes());
+    s.skip(2);
+    EXPECT_EQ(0x13, s.read_1bytes());
+}
+
+/**
+* test the stream utility, write 2bytes
+*/
+VOID TEST(KernelStreamTest, StreamWrite2Bytes)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    
+    s.write_2bytes(0x1011);
+    s.write_2bytes(0x1213);
+    s.write_2bytes(0x1415);
+    s.write_2bytes(0x1617);
+    s.write_2bytes(0x1819);
+
+    s.skip(-1 * s.pos());
+    EXPECT_EQ(0x10, s.read_1bytes());
+    s.skip(2);
+    EXPECT_EQ(0x13, s.read_1bytes());
+    s.skip(5);
+    EXPECT_EQ(0x19, s.read_1bytes());
+}
+
+/**
+* test the stream utility, write 3bytes
+*/
+VOID TEST(KernelStreamTest, StreamWrite3Bytes)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    
+    s.write_3bytes(0x101112);
+    s.write_3bytes(0x131415);
+    s.write_3bytes(0x161718);
+    s.write_3bytes(0x192021);
+
+    s.skip(-1 * s.pos());
+    EXPECT_EQ(0x10, s.read_1bytes());
+    s.skip(2);
+    EXPECT_EQ(0x13, s.read_1bytes());
+    s.skip(5);
+    EXPECT_EQ(0x19, s.read_1bytes());
+}
+
+/**
+* test the stream utility, write 34bytes
+*/
+VOID TEST(KernelStreamTest, StreamWrite4Bytes)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    
+    s.write_4bytes(0x10111213);
+    s.write_4bytes(0x14151617);
+    s.write_4bytes(0x18192021);
+
+    s.skip(-1 * s.pos());
+    EXPECT_EQ(0x10, s.read_1bytes());
+    s.skip(2);
+    EXPECT_EQ(0x13, s.read_1bytes());
+    s.skip(5);
+    EXPECT_EQ(0x19, s.read_1bytes());
+}
+
+/**
+* test the stream utility, write 8bytes
+*/
+VOID TEST(KernelStreamTest, StreamWrite8Bytes)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    
+    s.write_8bytes(0x1011121314151617);
+    s.write_8bytes(0x1819202122232425);
+
+    s.skip(-1 * s.pos());
+    EXPECT_EQ(0x10, s.read_1bytes());
+    s.skip(2);
+    EXPECT_EQ(0x13, s.read_1bytes());
+    s.skip(5);
+    EXPECT_EQ(0x19, s.read_1bytes());
+}
+
+/**
+* test the stream utility, write string
+*/
+VOID TEST(KernelStreamTest, StreamWriteString)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    
+    char str[] = {
+        (char)0x10, (char)0x11, (char)0x12, (char)0x13,
+        (char)0x14, (char)0x15, (char)0x16, (char)0x17, 
+        (char)0x18, (char)0x19, (char)0x20, (char)0x21
+    };
+    string str1;
+    str1.append(str, 12);
+    
+    s.write_string(str1);
+
+    s.skip(-1 * s.pos());
+    EXPECT_EQ(0x10, s.read_1bytes());
+    s.skip(2);
+    EXPECT_EQ(0x13, s.read_1bytes());
+    s.skip(5);
+    EXPECT_EQ(0x19, s.read_1bytes());
+}
+
+/**
+* test the stream utility, write bytes
+*/
+VOID TEST(KernelStreamTest, StreamWriteBytes)
+{
+    SrsStream s;
+    char data[1024];
+    
+    EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024));
+    
+    char str[] = {
+        (char)0x10, (char)0x11, (char)0x12, (char)0x13,
+        (char)0x14, (char)0x15, (char)0x16, (char)0x17, 
+        (char)0x18, (char)0x19, (char)0x20, (char)0x21
+    };
+    
+    s.write_bytes(str, 12);
+
+    s.skip(-1 * s.pos());
+    EXPECT_EQ(0x10, s.read_1bytes());
+    s.skip(2);
+    EXPECT_EQ(0x13, s.read_1bytes());
+    s.skip(5);
+    EXPECT_EQ(0x19, s.read_1bytes());
+}
+
+/**
+* test the kernel utility, time
+*/
+VOID TEST(KernelUtilityTest, UtilityTime)
+{
+    int64_t time = srs_get_system_time_ms();
+    EXPECT_TRUE(time > 0);
+    
+    int64_t time1 = srs_get_system_time_ms();
+    EXPECT_EQ(time, time1);
+    
+    usleep(1000);
+    srs_update_system_time_ms();
+    time1 = srs_get_system_time_ms();
+    EXPECT_TRUE(time1 > time);
+}
+
+/**
+* test the kernel utility, startup time
+*/
+VOID TEST(KernelUtilityTest, UtilityStartupTime)
+{
+    int64_t time = srs_get_system_startup_time_ms();
+    EXPECT_TRUE(time > 0);
+    
+    int64_t time1 = srs_get_system_startup_time_ms();
+    EXPECT_EQ(time, time1);
+    
+    usleep(1000);
+    srs_update_system_time_ms();
+    time1 = srs_get_system_startup_time_ms();
+    EXPECT_EQ(time, time1);
+}
+
+/**
+* test the kernel utility, little endian
+*/
+VOID TEST(KernelUtilityTest, UtilityLittleEndian)
+{
+    EXPECT_TRUE(srs_is_little_endian());
+}
+
+/**
+* test the kernel utility, string
+*/
+VOID TEST(KernelUtilityTest, UtilityString)
+{
+    string str = "Hello, World! Hello, SRS!";
+    string str1;
+    
+    str1 = srs_string_replace(str, "xxx", "");
+    EXPECT_STREQ("Hello, World! Hello, SRS!", str1.c_str());
+    
+    str1 = srs_string_replace(str, "He", "XX");
+    EXPECT_STREQ("XXllo, World! XXllo, SRS!", str1.c_str());
+    
+    str1 = srs_string_replace(str, "o", "XX");
+    EXPECT_STREQ("HellXX, WXXrld! HellXX, SRS!", str1.c_str());
+    
+    str1 = srs_string_trim_end(str, "x");
+    EXPECT_STREQ("Hello, World! Hello, SRS!", str1.c_str());
+    
+    str1 = srs_string_trim_end(str, "He");
+    EXPECT_STREQ("Hello, World! Hello, SRS!", str1.c_str());
+    
+    str1 = srs_string_trim_end(str, "HeS!R");
+    EXPECT_STREQ("Hello, World! Hello, ", str1.c_str());
+    
+    str1 = srs_string_remove(str, "x");
+    EXPECT_STREQ("Hello, World! Hello, SRS!", str1.c_str());
+    
+    str1 = srs_string_remove(str, "o");
+    EXPECT_STREQ("Hell, Wrld! Hell, SRS!", str1.c_str());
+    
+    str1 = srs_string_remove(str, "ol");
+    EXPECT_STREQ("He, Wrd! He, SRS!", str1.c_str());
+    
+    EXPECT_FALSE(srs_string_ends_with("Hello", "x"));
+    EXPECT_TRUE(srs_string_ends_with("Hello", "o"));
+    EXPECT_TRUE(srs_string_ends_with("Hello", "lo"));
+}