diff --git a/trunk/3rdparty/httpx-static/main.go b/trunk/3rdparty/httpx-static/main.go
index 39cffa1e3..f2a86bf26 100644
--- a/trunk/3rdparty/httpx-static/main.go
+++ b/trunk/3rdparty/httpx-static/main.go
@@ -262,6 +262,12 @@ func run(ctx context.Context) error {
 	flag.Var(&skeys, "skey", "the SSL key for domain")
 	flag.Var(&scerts, "scert", "the SSL cert for domain")
 
+	var trimSlashLimit int
+	var noRedirectIndex, trimLastSlash bool
+	flag.BoolVar(&noRedirectIndex, "no-redirect-index", false, "Whether serve with index.html without redirect.")
+	flag.BoolVar(&trimLastSlash, "trim-last-slash", false, "Whether trim last slash by HTTP redirect(302).")
+	flag.IntVar(&trimSlashLimit, "trim-slash-limit", 0, "Only trim last slash when got enough directories.")
+
 	flag.Usage = func() {
 		fmt.Println(fmt.Sprintf("Usage: %v -t http -s https -d domains -r root -e cache -l lets -k ssk -c ssc -p proxy", os.Args[0]))
 		fmt.Println(fmt.Sprintf("	"))
@@ -272,6 +278,8 @@ func run(ctx context.Context) error {
 		fmt.Println(fmt.Sprintf("			Listen at port for HTTPS server. Default: 0, disable HTTPS."))
 		fmt.Println(fmt.Sprintf("	-r, -root string"))
 		fmt.Println(fmt.Sprintf("			The www root path. Supports relative to argv[0]=%v. Default: ./html", path.Dir(os.Args[0])))
+		fmt.Println(fmt.Sprintf("	-no-redirect-index=bool"))
+		fmt.Println(fmt.Sprintf("			Whether serve with index.html without redirect. Default: false"))
 		fmt.Println(fmt.Sprintf("	-p, -proxy string"))
 		fmt.Println(fmt.Sprintf("			Proxy path to backend. For example: http://127.0.0.1:8888/api/webrtc"))
 		fmt.Println(fmt.Sprintf("			Proxy path to backend. For example: http://127.0.0.1:8888/api/webrtc?modifyRequestHost=false"))
@@ -317,6 +325,12 @@ func run(ctx context.Context) error {
 		os.Exit(-1)
 	}
 
+	// If trim last slash, we should enable no redirect index, to avoid infinitely redirect.
+	if trimLastSlash {
+		noRedirectIndex = true
+	}
+	fmt.Println(fmt.Sprintf("Config trimLastSlash=%v, trimSlashLimit=%v, noRedirectIndex=%v", trimLastSlash, trimSlashLimit, noRedirectIndex))
+
 	var proxyUrls []*url.URL
 	proxies := make(map[string]*url.URL)
 	for _, oproxy := range []string(oproxies) {
@@ -366,7 +380,34 @@ func run(ctx context.Context) error {
 		html = path.Join(path.Dir(os.Args[0]), html)
 	}
 
-	fs := http.FileServer(http.Dir(html))
+	serveFileNoRedirect := func (w http.ResponseWriter, r *http.Request, name string) {
+		upath := path.Join(html, path.Clean(r.URL.Path))
+
+		// Redirect without the last slash.
+		if trimLastSlash && r.URL.Path != "/" && strings.HasSuffix(r.URL.Path, "/") {
+			u := strings.TrimSuffix(r.URL.Path, "/")
+			if r.URL.RawQuery != "" {
+				u += "?" + r.URL.RawQuery
+			}
+			if strings.Count(u, "/") >= trimSlashLimit {
+				http.Redirect(w, r, u, http.StatusFound)
+				return
+			}
+		}
+
+		// Append the index.html path if access a directory.
+		if noRedirectIndex && !strings.Contains(path.Base(upath), ".") {
+			if d, err := os.Stat(upath); err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			} else if d.IsDir() {
+				upath = path.Join(upath, "index.html")
+			}
+		}
+
+		http.ServeFile(w, r, upath)
+	}
+
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		oh.SetHeader(w)
 
@@ -388,7 +429,7 @@ func run(ctx context.Context) error {
 				return
 			}
 
-			fs.ServeHTTP(w, r)
+			serveFileNoRedirect(w, r, path.Join(html, path.Clean(r.URL.Path)))
 			return
 		}
 
@@ -417,7 +458,7 @@ func run(ctx context.Context) error {
 			}
 		}
 
-		fs.ServeHTTP(w, r)
+		serveFileNoRedirect(w, r, path.Join(html, path.Clean(r.URL.Path)))
 	})
 
 	var protos []string
diff --git a/trunk/3rdparty/httpx-static/version.go b/trunk/3rdparty/httpx-static/version.go
index 3a48b053b..12a9cdbb1 100644
--- a/trunk/3rdparty/httpx-static/version.go
+++ b/trunk/3rdparty/httpx-static/version.go
@@ -35,7 +35,7 @@ func VersionMinor() int {
 }
 
 func VersionRevision() int {
-	return 19
+	return 26
 }
 
 func Version() string {
diff --git a/trunk/configure b/trunk/configure
index af078f077..7798be411 100755
--- a/trunk/configure
+++ b/trunk/configure
@@ -387,9 +387,10 @@ fi
 #
 # utest, the unit-test cases of srs, base on gtest1.6
 if [ $SRS_UTEST = YES ]; then
-    MODULE_FILES=("srs_utest" "srs_utest_amf0" "srs_utest_protocol" "srs_utest_kernel" "srs_utest_core"
+    MODULE_FILES=("srs_utest" "srs_utest_amf0" "srs_utest_kernel" "srs_utest_core"
         "srs_utest_config" "srs_utest_rtmp" "srs_utest_http" "srs_utest_avc" "srs_utest_reload"
-        "srs_utest_mp4" "srs_utest_service" "srs_utest_app" "srs_utest_rtc" "srs_utest_protocol2")
+        "srs_utest_mp4" "srs_utest_service" "srs_utest_app" "srs_utest_rtc"
+        "srs_utest_protocol")
     if [[ $SRS_SRT == YES ]]; then
         MODULE_FILES+=("srs_utest_srt")
     fi
diff --git a/trunk/research/console/js/srs.console.js b/trunk/research/console/js/srs.console.js
index 18d452276..031786e7a 100644
--- a/trunk/research/console/js/srs.console.js
+++ b/trunk/research/console/js/srs.console.js
@@ -578,6 +578,23 @@ scApp.filter('sc_filter_preview_url', ['$sc_server', function($sc_server){
     };
 }]);
 
+scApp.filter('sc_filter_streamURL', function(){
+    return function(v){
+        if (!v || !v.url) return '';
+
+        const pos = v.url.lastIndexOf('/');
+        const stream = pos < 0 ? '' : v.url.substr(pos);
+
+        const pos2 = v.tcUrl.indexOf('?');
+        const tcUrl = pos2 < 0 ? v.tcUrl : v.tcUrl.substr(0, pos2);
+
+        let params = pos2 < 0 ? '' : v.tcUrl.substr(pos2);
+        if (params === '?vhost=__defaultVhost__' || params === '?domain=__defaultVhost__') params = '';
+
+        return `${tcUrl}${stream}${params}`;
+    };
+});
+
 // the sc nav is the nevigator
 scApp.provider("$sc_nav", function(){
     this.$get = function(){
diff --git a/trunk/research/console/views/clients.html b/trunk/research/console/views/clients.html
index 368ed8c7a..1724148ba 100644
--- a/trunk/research/console/views/clients.html
+++ b/trunk/research/console/views/clients.html
@@ -16,7 +16,8 @@
                             <th>Stream</th>
                             <th>类型</th>
                             <th>时长</th>
-                            <th>TcUrl</th>
+                            <th>URL</th>
+                            <th>分类</th>
                             <th>管理</th>
                         </tr>
                         <tr ng-repeat="client in clients">
@@ -26,7 +27,8 @@
                             <td><a href="javascript:void(0)" ng-click="gogogo('/streams/' + client.stream)">{{client.stream}}</a></td>
                             <td>{{client.publish| sc_filter_ctype}}</td>
                             <td>{{client.alive| sc_filter_time}}</td>
-                            <td>{{client.tcUrl}}</td>
+                            <td>{{client |sc_filter_streamURL}}</td>
+                            <td>{{client.type}}</td>
                             <td>
                                 <a ng-click="kickoff(client)" href="javascript:void(0)">踢Ta</a>
                             </td>
diff --git a/trunk/research/console/views/clients_en.html b/trunk/research/console/views/clients_en.html
index b13b2a81e..01dda4535 100644
--- a/trunk/research/console/views/clients_en.html
+++ b/trunk/research/console/views/clients_en.html
@@ -16,7 +16,8 @@
                             <th>Stream</th>
                             <th>Type</th>
                             <th>Duration</th>
-                            <th>TcUrl</th>
+                            <th>URL</th>
+                            <th>Category</th>
                             <th>Manage</th>
                         </tr>
                         <tr ng-repeat="client in clients">
@@ -26,7 +27,8 @@
                             <td><a href="javascript:void(0)" ng-click="gogogo('/streams/' + client.stream)">{{client.stream}}</a></td>
                             <td>{{client.publish| sc_filter_ctype}}</td>
                             <td>{{client.alive| sc_filter_time}}</td>
-                            <td>{{client.tcUrl}}</td>
+                            <td>{{client |sc_filter_streamURL}}</td>
+                            <td>{{client.type}}</td>
                             <td>
                                 <a ng-click="kickoff(client)" href="javascript:void(0)">Kickoff It</a>
                             </td>
diff --git a/trunk/src/utest/srs_utest_protocol.cpp b/trunk/src/utest/srs_utest_protocol.cpp
index 8bc6a34da..7b3cacee5 100644
--- a/trunk/src/utest/srs_utest_protocol.cpp
+++ b/trunk/src/utest/srs_utest_protocol.cpp
@@ -1994,2055 +1994,6 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVFmt3)
     }
 }
 
-/**
-* recv video, audio, video and video, interlaced in chunks.
-*/
-VOID TEST(ProtocolStackTest, ProtocolRecvVAVVMessage)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x03,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x04,
-            0x00, 0x00, 0x15, // timestamp
-            0x00, 0x00, 0x90, // length, 144
-            0x08, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x03,
-            0x00, 0x00, 0x20, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC4, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x03,
-            0x00, 0x00, 0x30, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x10, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_audio());
-        EXPECT_EQ(0x15, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x20, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x30, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-}
-
-/**
-* recv video, audio, video and video, interlaced in chunks.
-* the continue chunks use fmt=1 header
-*/
-VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt1)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    /**
-    * parse the message header.
-    *   3bytes: timestamp delta,    fmt=0,1,2
-    *   3bytes: payload length,     fmt=0,1
-    *   1bytes: message type,       fmt=0,1
-    *   4bytes: stream id,          fmt=0
-    * where:
-    *   fmt=0, 0x0X
-    *   fmt=1, 0x4X
-    *   fmt=2, 0x8X
-    *   fmt=3, 0xCX
-    */
-    
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x03,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x04,
-            0x00, 0x00, 0x15, // timestamp
-            0x00, 0x00, 0x90, // length, 144
-            0x08, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x43,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC4, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x43,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x10, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_audio());
-        EXPECT_EQ(0x15, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x20, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x30, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-}
-
-/**
-* recv video, audio, video and video, interlaced in chunks.
-* the continue chunks use fmt=2 header
-*/
-VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt2)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    /**
-    * parse the message header.
-    *   3bytes: timestamp delta,    fmt=0,1,2
-    *   3bytes: payload length,     fmt=0,1
-    *   1bytes: message type,       fmt=0,1
-    *   4bytes: stream id,          fmt=0
-    * where:
-    *   fmt=0, 0x0X
-    *   fmt=1, 0x4X
-    *   fmt=2, 0x8X
-    *   fmt=3, 0xCX
-    */
-    
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x03,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x04,
-            0x00, 0x00, 0x15, // timestamp
-            0x00, 0x00, 0x90, // length, 144
-            0x08, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x83,
-            0x00, 0x00, 0x10, // timestamp
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC4, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x83,
-            0x00, 0x00, 0x10, // timestamp
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x10, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_audio());
-        EXPECT_EQ(0x15, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x20, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x30, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-}
-
-/**
-* recv video, audio, video and video, interlaced in chunks.
-* the continue chunks use fmt=3 header
-*/
-VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt3)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    /**
-    * parse the message header.
-    *   3bytes: timestamp delta,    fmt=0,1,2
-    *   3bytes: payload length,     fmt=0,1
-    *   1bytes: message type,       fmt=0,1
-    *   4bytes: stream id,          fmt=0
-    * where:
-    *   fmt=0, 0x0X
-    *   fmt=1, 0x4X
-    *   fmt=2, 0x8X
-    *   fmt=3, 0xCX
-    */
-    
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x03,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x04,
-            0x00, 0x00, 0x15, // timestamp
-            0x00, 0x00, 0x90, // length, 144
-            0x08, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0xC3,
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC4, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0xC3,
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x10, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_audio());
-        EXPECT_EQ(0x15, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x20, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x30, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-}
-
-/**
-* recv video, audio, video and video, interlaced in chunks.
-* the continue chunks use fmt=1, last video with fmt=1 header
-*/
-VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    /**
-    * parse the message header.
-    *   3bytes: timestamp delta,    fmt=0,1,2
-    *   3bytes: payload length,     fmt=0,1
-    *   1bytes: message type,       fmt=0,1
-    *   4bytes: stream id,          fmt=0
-    * where:
-    *   fmt=0, 0x0X
-    *   fmt=1, 0x4X
-    *   fmt=2, 0x8X
-    *   fmt=3, 0xCX
-    */
-    
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x03,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x04,
-            0x00, 0x00, 0x15, // timestamp
-            0x00, 0x00, 0x90, // length, 144
-            0x08, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x43,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC4, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x43,
-            0x00, 0x00, 0x20, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x10, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_audio());
-        EXPECT_EQ(0x15, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x20, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x40, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-}
-
-/**
-* recv video, audio, video and video, interlaced in chunks.
-* the continue chunks use fmt=1, last video with fmt=1 header,
-* last video changed length
-*/
-VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11Length)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    /**
-    * parse the message header.
-    *   3bytes: timestamp delta,    fmt=0,1,2
-    *   3bytes: payload length,     fmt=0,1
-    *   1bytes: message type,       fmt=0,1
-    *   4bytes: stream id,          fmt=0
-    * where:
-    *   fmt=0, 0x0X
-    *   fmt=1, 0x4X
-    *   fmt=2, 0x8X
-    *   fmt=3, 0xCX
-    */
-    
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x03,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x04,
-            0x00, 0x00, 0x15, // timestamp
-            0x00, 0x00, 0x90, // length, 144
-            0x08, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x43,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x20, // length, 288
-            0x09, // message_type
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC4, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x43,
-            0x00, 0x00, 0x20, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x10, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_audio());
-        EXPECT_EQ(0x15, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x20, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x40, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-}
-
-/**
-* recv video, audio, video and video, interlaced in chunks.
-* the continue chunks use fmt=1, last video with fmt=2 header
-*/
-VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    /**
-    * parse the message header.
-    *   3bytes: timestamp delta,    fmt=0,1,2
-    *   3bytes: payload length,     fmt=0,1
-    *   1bytes: message type,       fmt=0,1
-    *   4bytes: stream id,          fmt=0
-    * where:
-    *   fmt=0, 0x0X
-    *   fmt=1, 0x4X
-    *   fmt=2, 0x8X
-    *   fmt=3, 0xCX
-    */
-    
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x03,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x04,
-            0x00, 0x00, 0x15, // timestamp
-            0x00, 0x00, 0x90, // length, 144
-            0x08, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x43,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC4, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x83,
-            0x00, 0x00, 0x20, // timestamp
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x10, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_audio());
-        EXPECT_EQ(0x15, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x20, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x40, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-}
-
-/**
-* recv video, audio, video and video, interlaced in chunks.
-* the continue chunks use fmt=1, last video with fmt=2 header,
-* last video changed length
-*/
-VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12Length)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    /**
-    * parse the message header.
-    *   3bytes: timestamp delta,    fmt=0,1,2
-    *   3bytes: payload length,     fmt=0,1
-    *   1bytes: message type,       fmt=0,1
-    *   4bytes: stream id,          fmt=0
-    * where:
-    *   fmt=0, 0x0X
-    *   fmt=1, 0x4X
-    *   fmt=2, 0x8X
-    *   fmt=3, 0xCX
-    */
-    
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x03,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x10, // length, 272
-            0x09, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x04,
-            0x00, 0x00, 0x15, // timestamp
-            0x00, 0x00, 0x90, // length, 144
-            0x08, // message_type
-            0x01, 0x00, 0x00, 0x00, // stream_id
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x43,
-            0x00, 0x00, 0x10, // timestamp
-            0x00, 0x01, 0x20, // length, 288
-            0x09, // message_type
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // audio message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC4, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#1
-    if (true) {
-        uint8_t data[] = {
-            // 12bytes header, 1byts chunk header, 11bytes msg heder
-            0x83,
-            0x00, 0x00, 0x20, // timestamp
-            // msg payload start
-            0x02, 0x00, 0x07, 0x63,
-            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#2
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    // video message, chunk#3
-    if (true) {
-        uint8_t data[] = {
-            0xC3, /*next chunk.*/
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-        };
-        bio.in_buffer.append((char*)data, sizeof(data));
-    }
-    
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x10, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-        EXPECT_EQ(0x110, msg->header.payload_length);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_audio());
-        EXPECT_EQ(0x15, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x20, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-        EXPECT_EQ(0x120, msg->header.payload_length);
-    }
-    if (true) {
-        SrsCommonMessage* msg = NULL;
-        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-        SrsAutoFree(SrsCommonMessage, msg);
-        EXPECT_TRUE(msg->header.is_video());
-        EXPECT_EQ(0x40, msg->header.timestamp);
-        EXPECT_EQ(0x01, msg->header.stream_id);
-        EXPECT_EQ(0x120, msg->header.payload_length);
-    }
-}
-
-/**
-* recv video, with extended timestamp.
-* small timestamp < 0xffffff
-*/
-VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    /**
-    * parse the message header.
-    *   3bytes: timestamp delta,    fmt=0,1,2
-    *   3bytes: payload length,     fmt=0,1
-    *   1bytes: message type,       fmt=0,1
-    *   4bytes: stream id,          fmt=0
-    * where:
-    *   fmt=0, 0x0X
-    *   fmt=1, 0x4X
-    *   fmt=2, 0x8X
-    *   fmt=3, 0xCX
-    */
-    
-    uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x03,
-        0xff, 0xff, 0xff, // timestamp
-        0x00, 0x00, 0x04, // length
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        0x00, 0x00, 0x00, 0x10, // extended timestamp
-        // msg payload start
-        0x00, 0x00, 0x07, 0x63
-    };
-    bio.in_buffer.append((char*)data, sizeof(data));
-    
-    SrsCommonMessage* msg = NULL;
-    ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-    SrsAutoFree(SrsCommonMessage, msg);
-    EXPECT_TRUE(msg->header.is_video());
-    EXPECT_EQ(0x10, msg->header.timestamp);
-}
-
-/**
-* recv video, with extended timestamp.
-* big timestamp > 0xffffff
-*/
-VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage2)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    /**
-    * parse the message header.
-    *   3bytes: timestamp delta,    fmt=0,1,2
-    *   3bytes: payload length,     fmt=0,1
-    *   1bytes: message type,       fmt=0,1
-    *   4bytes: stream id,          fmt=0
-    * where:
-    *   fmt=0, 0x0X
-    *   fmt=1, 0x4X
-    *   fmt=2, 0x8X
-    *   fmt=3, 0xCX
-    */
-    
-    uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x03,
-        0xff, 0xff, 0xff, // timestamp
-        0x00, 0x00, 0x04, // length
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        0x7f, 0x01, 0x02, 0x03, // extended timestamp
-        // msg payload start
-        0x00, 0x00, 0x07, 0x63
-    };
-    bio.in_buffer.append((char*)data, sizeof(data));
-    
-    SrsCommonMessage* msg = NULL;
-    ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-    SrsAutoFree(SrsCommonMessage, msg);
-    EXPECT_TRUE(msg->header.is_video());
-    EXPECT_EQ(0x7f010203, msg->header.timestamp);
-}
-
-/**
-* recv video, with extended timestamp.
-* always use 31bits timestamp.
-*/
-// always use 31bits timestamp, for some server may use 32bits extended timestamp.
-VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage3)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    /**
-    * parse the message header.
-    *   3bytes: timestamp delta,    fmt=0,1,2
-    *   3bytes: payload length,     fmt=0,1
-    *   1bytes: message type,       fmt=0,1
-    *   4bytes: stream id,          fmt=0
-    * where:
-    *   fmt=0, 0x0X
-    *   fmt=1, 0x4X
-    *   fmt=2, 0x8X
-    *   fmt=3, 0xCX
-    */
-    
-    uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x03,
-        0xff, 0xff, 0xff, // timestamp
-        0x00, 0x00, 0x04, // length
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        0xff, 0x01, 0x02, 0x03, // extended timestamp
-        // msg payload start
-        0x00, 0x00, 0x07, 0x63
-    };
-    bio.in_buffer.append((char*)data, sizeof(data));
-    
-    SrsCommonMessage* msg = NULL;
-    ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-    SrsAutoFree(SrsCommonMessage, msg);
-    EXPECT_TRUE(msg->header.is_video());
-    // always use 31bits timestamp
-    EXPECT_EQ(0x7f010203, msg->header.timestamp);
-}
-
-/**
-* recv video, with extended timestamp, in 2 chunks packet.
-* always send extended timestamp in 0xCX chunk packets.
-*/
-/**
-* RTMP specification and ffmpeg/librtmp is false,
-* but, adobe changed the specification, so flash/FMLE/FMS always true.
-* default to true to support flash/FMLE/FMS.
-* 
-* ffmpeg/librtmp may donot send this filed, need to detect the value.
-* @see also: http://blog.csdn.net/win_lin/article/details/13363699
-* compare to the chunk timestamp, which is set by chunk message header
-* type 0,1 or 2.
-*
-* @remark, nginx send the extended-timestamp in sequence-header,
-* and timestamp delta in continue C1 chunks, and so compatible with ffmpeg,
-* that is, there is no continue chunks and extended-timestamp in nginx-rtmp.
-*
-* @remark, srs always send the extended-timestamp, to keep simple,
-* and compatible with adobe products.
-*/
-VOID TEST(ProtocolStackTest, ProtocolRecvVExtTime2Trunk)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    // video message
-    uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x03,
-        0xff, 0xff, 0xff, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        0x00, 0x01, 0x02, 0x03, // extended timestamp
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        // chunk #2
-        0xC3,
-        0x00, 0x01, 0x02, 0x03, // extended timestamp
-        /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        // chunk #2
-        0xC3,
-        0x00, 0x01, 0x02, 0x03, // extended timestamp
-        /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-    };
-    bio.in_buffer.append((char*)data, sizeof(data));
-    
-    SrsCommonMessage* msg = NULL;
-    ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-    SrsAutoFree(SrsCommonMessage, msg);
-    EXPECT_TRUE(msg->header.is_video());
-    // 0xCX with extended timestamp.
-    EXPECT_EQ(0x00010203, msg->header.timestamp);
-}
-
-/**
-* recv video, with extended timestamp, in 2 chunks packet.
-* never send extended timestamp in 0xCX chunk packets.
-*/
-// FFMPEG/librtmp, RTMP specification standard protocol.
-VOID TEST(ProtocolStackTest, ProtocolRecvVExtTime2Trunk2)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    // video message
-    uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x03,
-        0xff, 0xff, 0xff, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        0x00, 0x01, 0x02, 0x03, // extended timestamp
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        // chunk #2
-        0xC3,
-        /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        // chunk #2
-        0xC3,
-        /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-    };
-    bio.in_buffer.append((char*)data, sizeof(data));
-    
-    SrsCommonMessage* msg = NULL;
-    ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-    SrsAutoFree(SrsCommonMessage, msg);
-    EXPECT_TRUE(msg->header.is_video());
-    // 0xCX without extended timestamp.
-    EXPECT_EQ(0x00010203, msg->header.timestamp);
-}
-
-/**
-* a video message, in 2 chunks packet.
-* use 1B chunk header, min chunk id is 2.
-*/
-VOID TEST(ProtocolStackTest, ProtocolRecvVCid1BMin)
-{
-    MockBufferIO bio;
-    SrsProtocol proto(&bio);
-    
-    // video message
-    uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x02,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        // chunk #2
-        0xC2, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        // chunk #2
-        0xC2, /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
-    };
-    bio.in_buffer.append((char*)data, sizeof(data));
-    
-    SrsCommonMessage* msg = NULL;
-    ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
-    SrsAutoFree(SrsCommonMessage, msg);
-    EXPECT_TRUE(msg->header.is_video());
-    // 1B cid(6bits), min is 2
-    EXPECT_EQ(0x02, msg->header.perfer_cid);
-}
-
 /**
 * a video message, in 2 chunks packet.
 * use 1B chunk header, cid in 2-63
@@ -4204,41 +2155,41 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid2BNormal)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // video message
     uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x00, 0x10,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        // chunk #2
-        0xC0, 0x10, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        // chunk #2
-        0xC0, 0x10, /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x00, 0x10,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            // chunk #2
+            0xC0, 0x10, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // chunk #2
+            0xC0, 0x10, /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
     };
     bio.in_buffer.append((char*)data, sizeof(data));
-    
+
     SrsCommonMessage* msg = NULL;
     ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
     SrsAutoFree(SrsCommonMessage, msg);
@@ -4255,41 +2206,41 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid2BNormal2)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // video message
     uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x00, 0x11,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        // chunk #2
-        0xC0, 0x11, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        // chunk #2
-        0xC0, 0x11, /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x00, 0x11,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            // chunk #2
+            0xC0, 0x11, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // chunk #2
+            0xC0, 0x11, /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
     };
     bio.in_buffer.append((char*)data, sizeof(data));
-    
+
     SrsCommonMessage* msg = NULL;
     ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
     SrsAutoFree(SrsCommonMessage, msg);
@@ -4306,41 +2257,41 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid2BMax)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // video message
     uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x00, 0xFF,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        // chunk #2
-        0xC0, 0xFF, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        // chunk #2
-        0xC0, 0xFF, /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x00, 0xFF,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            // chunk #2
+            0xC0, 0xFF, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // chunk #2
+            0xC0, 0xFF, /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
     };
     bio.in_buffer.append((char*)data, sizeof(data));
-    
+
     SrsCommonMessage* msg = NULL;
     ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
     SrsAutoFree(SrsCommonMessage, msg);
@@ -4357,41 +2308,41 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid3BMin)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // video message
     uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x01, 0x00, 0x00,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        // chunk #2
-        0xC1, 0x00, 0x00, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        // chunk #2
-        0xC1, 0x00, 0x00, /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x01, 0x00, 0x00,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            // chunk #2
+            0xC1, 0x00, 0x00, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // chunk #2
+            0xC1, 0x00, 0x00, /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
     };
     bio.in_buffer.append((char*)data, sizeof(data));
-    
+
     SrsCommonMessage* msg = NULL;
     ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
     SrsAutoFree(SrsCommonMessage, msg);
@@ -4408,41 +2359,41 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid3BNormal)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // video message
     uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x01, 0x00, 0x10,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        // chunk #2
-        0xC1, 0x00, 0x10, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        // chunk #2
-        0xC1, 0x00, 0x10, /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x01, 0x00, 0x10,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            // chunk #2
+            0xC1, 0x00, 0x10, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // chunk #2
+            0xC1, 0x00, 0x10, /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
     };
     bio.in_buffer.append((char*)data, sizeof(data));
-    
+
     SrsCommonMessage* msg = NULL;
     ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
     SrsAutoFree(SrsCommonMessage, msg);
@@ -4459,41 +2410,41 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid3BNormal2)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // video message
     uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x01, 0x01, 0x10,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        // chunk #2
-        0xC1, 0x01, 0x10, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        // chunk #2
-        0xC1, 0x01, 0x10, /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x01, 0x01, 0x10,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            // chunk #2
+            0xC1, 0x01, 0x10, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // chunk #2
+            0xC1, 0x01, 0x10, /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
     };
     bio.in_buffer.append((char*)data, sizeof(data));
-    
+
     SrsCommonMessage* msg = NULL;
     ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
     SrsAutoFree(SrsCommonMessage, msg);
@@ -4510,41 +2461,41 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid3BNormal3)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // video message
     uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x01, 0xFF, 0x10,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        // chunk #2
-        0xC1, 0xFF, 0x10, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        // chunk #2
-        0xC1, 0xFF, 0x10, /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x01, 0xFF, 0x10,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            // chunk #2
+            0xC1, 0xFF, 0x10, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // chunk #2
+            0xC1, 0xFF, 0x10, /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
     };
     bio.in_buffer.append((char*)data, sizeof(data));
-    
+
     SrsCommonMessage* msg = NULL;
     ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
     SrsAutoFree(SrsCommonMessage, msg);
@@ -4561,41 +2512,41 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid3BNormal4)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // video message
     uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x01, 0x02, 0x10,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        // chunk #2
-        0xC1, 0x02, 0x10, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        // chunk #2
-        0xC1, 0x02, 0x10, /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x01, 0x02, 0x10,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            // chunk #2
+            0xC1, 0x02, 0x10, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // chunk #2
+            0xC1, 0x02, 0x10, /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
     };
     bio.in_buffer.append((char*)data, sizeof(data));
-    
+
     SrsCommonMessage* msg = NULL;
     ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
     SrsAutoFree(SrsCommonMessage, msg);
@@ -4612,41 +2563,41 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid3BMax)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // video message
     uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x01, 0xFF, 0xFF,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        // chunk #2
-        0xC1, 0xFF, 0xFF, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        // chunk #2
-        0xC1, 0xFF, 0xFF, /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x01, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            // chunk #2
+            0xC1, 0xFF, 0xFF, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // chunk #2
+            0xC1, 0xFF, 0xFF, /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
     };
     bio.in_buffer.append((char*)data, sizeof(data));
-    
+
     SrsCommonMessage* msg = NULL;
     ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
     SrsAutoFree(SrsCommonMessage, msg);
@@ -4662,29 +2613,29 @@ VOID TEST(ProtocolStackTest, ProtocolRecvV0LenMessage)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // video message
     uint8_t data[] = {
-        // video #1
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x03,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x00, 0x00, // length
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        
-        // video #2
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x03,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x00, 0x04, // length
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        // msg payload start
-        0x00, 0x00, 0x07, 0x63
+            // video #1
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x03,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x00, 0x00, // length
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+
+            // video #2
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x03,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x00, 0x04, // length
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            // msg payload start
+            0x00, 0x00, 0x07, 0x63
     };
     bio.in_buffer.append((char*)data, sizeof(data));
-    
+
     SrsCommonMessage* msg = NULL;
     ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
     SrsAutoFree(SrsCommonMessage, msg);
@@ -4700,17 +2651,17 @@ VOID TEST(ProtocolStackTest, ProtocolSendVMessage)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     uint8_t data[] = {0x01, 0x02, 0x03, 0x04};
-    
+
     SrsCommonMessage* msg = new SrsCommonMessage();
     msg->size = sizeof(data);
     msg->payload = new char[msg->size];
     memcpy(msg->payload, data, msg->size);
-    
+
     SrsSharedPtrMessage m;
     ASSERT_TRUE(ERROR_SUCCESS == m.create(msg));
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_message(m.copy(), 0));
     EXPECT_EQ(16, bio.out_buffer.length());
 }
@@ -4722,37 +2673,37 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsCallPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsAmf0Object* args = SrsAmf0Any::object();
-    
+
     SrsCallPacket* pkt = new SrsCallPacket();
     pkt->command_name = "my_call";
     pkt->command_object = SrsAmf0Any::null();
     pkt->arguments = args;
-    
+
     args->set("video_id", SrsAmf0Any::number(100));
     args->set("url", SrsAmf0Any::str("http://ossrs.net/api/v1/videos/100"));
     args->set("date", SrsAmf0Any::str("2014-07-11 16:20:10.2984"));
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x14,
-        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x07, 0x6d,
-        0x79, 0x5f, 0x63, 0x61, 0x6c, 0x6c, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
-        0x03, 0x00, 0x08, 0x76, 0x69, 0x64, 0x65, 0x6f,
-        0x5f, 0x69, 0x64, 0x00, 0x40, 0x59, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x75, 0x72,
-        0x6c, 0x02, 0x00, 0x22, 0x68, 0x74, 0x74, 0x70,
-        0x3a, 0x2f, 0x2f, 0x6f, 0x73, 0x73, 0x72, 0x73,
-        0x2e, 0x6e, 0x65, 0x74, 0x2f, 0x61, 0x70, 0x69,
-        0x2f, 0x76, 0x31, 0x2f, 0x76, 0x69, 0x64, 0x65,
-        0x6f, 0x73, 0x2f, 0x31, 0x30, 0x30, 0x00, 0x04,
-        0x64, 0x61, 0x74, 0x65, 0x02, 0x00, 0x18, 0x32,
-        0x30, 0x31, 0x34, 0x2d, 0x30, 0x37, 0x2d, 0x31,
-        0x31, 0x20, 0x31, 0x36, 0x3a, 0x32, 0x30, 0x3a,
-        0x31, 0x30, 0x2e, 0x32, 0x39, 0x38, 0x34, 0x00,
-        0x00, 0x09
+            0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x14,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x07, 0x6d,
+            0x79, 0x5f, 0x63, 0x61, 0x6c, 0x6c, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+            0x03, 0x00, 0x08, 0x76, 0x69, 0x64, 0x65, 0x6f,
+            0x5f, 0x69, 0x64, 0x00, 0x40, 0x59, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x75, 0x72,
+            0x6c, 0x02, 0x00, 0x22, 0x68, 0x74, 0x74, 0x70,
+            0x3a, 0x2f, 0x2f, 0x6f, 0x73, 0x73, 0x72, 0x73,
+            0x2e, 0x6e, 0x65, 0x74, 0x2f, 0x61, 0x70, 0x69,
+            0x2f, 0x76, 0x31, 0x2f, 0x76, 0x69, 0x64, 0x65,
+            0x6f, 0x73, 0x2f, 0x31, 0x30, 0x30, 0x00, 0x04,
+            0x64, 0x61, 0x74, 0x65, 0x02, 0x00, 0x18, 0x32,
+            0x30, 0x31, 0x34, 0x2d, 0x30, 0x37, 0x2d, 0x31,
+            0x31, 0x20, 0x31, 0x36, 0x3a, 0x32, 0x30, 0x3a,
+            0x31, 0x30, 0x2e, 0x32, 0x39, 0x38, 0x34, 0x00,
+            0x00, 0x09
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
 }
@@ -4764,37 +2715,37 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsCallResPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsAmf0Object* args = SrsAmf0Any::object();
-    
+
     SrsCallResPacket* pkt = new SrsCallResPacket(0);
     pkt->command_name = "_result";
     pkt->command_object = SrsAmf0Any::null();
     pkt->response = args;
-    
+
     args->set("video_id", SrsAmf0Any::number(100));
     args->set("url", SrsAmf0Any::str("http://ossrs.net/api/v1/videos/100"));
     args->set("date", SrsAmf0Any::str("2014-07-11 16:20:10.2984"));
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x14,
-        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x07, 0x5f,
-        0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
-        0x03, 0x00, 0x08, 0x76, 0x69, 0x64, 0x65, 0x6f,
-        0x5f, 0x69, 0x64, 0x00, 0x40, 0x59, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x75, 0x72,
-        0x6c, 0x02, 0x00, 0x22, 0x68, 0x74, 0x74, 0x70,
-        0x3a, 0x2f, 0x2f, 0x6f, 0x73, 0x73, 0x72, 0x73,
-        0x2e, 0x6e, 0x65, 0x74, 0x2f, 0x61, 0x70, 0x69,
-        0x2f, 0x76, 0x31, 0x2f, 0x76, 0x69, 0x64, 0x65,
-        0x6f, 0x73, 0x2f, 0x31, 0x30, 0x30, 0x00, 0x04,
-        0x64, 0x61, 0x74, 0x65, 0x02, 0x00, 0x18, 0x32,
-        0x30, 0x31, 0x34, 0x2d, 0x30, 0x37, 0x2d, 0x31,
-        0x31, 0x20, 0x31, 0x36, 0x3a, 0x32, 0x30, 0x3a,
-        0x31, 0x30, 0x2e, 0x32, 0x39, 0x38, 0x34, 0x00,
-        0x00, 0x09
+            0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x14,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x07, 0x5f,
+            0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+            0x03, 0x00, 0x08, 0x76, 0x69, 0x64, 0x65, 0x6f,
+            0x5f, 0x69, 0x64, 0x00, 0x40, 0x59, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x75, 0x72,
+            0x6c, 0x02, 0x00, 0x22, 0x68, 0x74, 0x74, 0x70,
+            0x3a, 0x2f, 0x2f, 0x6f, 0x73, 0x73, 0x72, 0x73,
+            0x2e, 0x6e, 0x65, 0x74, 0x2f, 0x61, 0x70, 0x69,
+            0x2f, 0x76, 0x31, 0x2f, 0x76, 0x69, 0x64, 0x65,
+            0x6f, 0x73, 0x2f, 0x31, 0x30, 0x30, 0x00, 0x04,
+            0x64, 0x61, 0x74, 0x65, 0x02, 0x00, 0x18, 0x32,
+            0x30, 0x31, 0x34, 0x2d, 0x30, 0x37, 0x2d, 0x31,
+            0x31, 0x20, 0x31, 0x36, 0x3a, 0x32, 0x30, 0x3a,
+            0x31, 0x30, 0x2e, 0x32, 0x39, 0x38, 0x34, 0x00,
+            0x00, 0x09
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
 }
@@ -4806,17 +2757,17 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsCreateStreamPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsCreateStreamPacket* pkt = new SrsCreateStreamPacket();
     pkt->command_object = SrsAmf0Any::null();
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x14,
-        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0c, 0x63,
-        0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x74, 0x72,
-        0x65, 0x61, 0x6d, 0x00, 0x40, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x05
+            0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x14,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0c, 0x63,
+            0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x74, 0x72,
+            0x65, 0x61, 0x6d, 0x00, 0x40, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x05
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
 }
@@ -4828,20 +2779,20 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsFMLEStartPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsFMLEStartPacket* pkt = new SrsFMLEStartPacket();
     pkt->command_name = "FMLEStart";
     pkt->command_object = SrsAmf0Any::null();
     pkt->stream_name = "livestream";
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x14,
-        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x09, 0x46,
-        0x4d, 0x4c, 0x45, 0x53, 0x74, 0x61, 0x72, 0x74,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x05, 0x02, 0x00, 0x0a, 0x6c, 0x69, 0x76,
-        0x65, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d
+            0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x14,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x09, 0x46,
+            0x4d, 0x4c, 0x45, 0x53, 0x74, 0x61, 0x72, 0x74,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x05, 0x02, 0x00, 0x0a, 0x6c, 0x69, 0x76,
+            0x65, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
 }
@@ -4853,24 +2804,24 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsFMLEStartResPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsAmf0Object* args = SrsAmf0Any::object();
-    
+
     SrsFMLEStartResPacket* pkt = new SrsFMLEStartResPacket(1);
     pkt->command_name = "FMLEStart";
     pkt->command_object = SrsAmf0Any::null();
     pkt->args = args;
-    
+
     args->set("stream" , SrsAmf0Any::str("livestream"));
     args->set("start" , SrsAmf0Any::number(0));
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     uint8_t buf[] = {
-        0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x14,
-        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x09, 0x46,
-        0x4d, 0x4c, 0x45, 0x53, 0x74, 0x61, 0x72, 0x74,
-        0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x05, 0x06
+            0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x14,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x09, 0x46,
+            0x4d, 0x4c, 0x45, 0x53, 0x74, 0x61, 0x72, 0x74,
+            0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x05, 0x06
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), (char*)buf, sizeof(buf)));
 }
@@ -4882,22 +2833,22 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsPublishPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsPublishPacket* pkt = new SrsPublishPacket();
     pkt->command_name = "publish";
     pkt->command_object = SrsAmf0Any::null();
     pkt->stream_name = "livestream";
     pkt->type = "live";
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     uint8_t buf[] = {
-        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x14,
-        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x07, 0x70,
-        0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
-        0x02, 0x00, 0x0a, 0x6c, 0x69, 0x76, 0x65, 0x73,
-        0x74, 0x72, 0x65, 0x61, 0x6d, 0x02, 0x00, 0x04,
-        0x6c, 0x69, 0x76, 0x65
+            0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x14,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x07, 0x70,
+            0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+            0x02, 0x00, 0x0a, 0x6c, 0x69, 0x76, 0x65, 0x73,
+            0x74, 0x72, 0x65, 0x61, 0x6d, 0x02, 0x00, 0x04,
+            0x6c, 0x69, 0x76, 0x65
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), (char*)buf, sizeof(buf)));
 }
@@ -4909,29 +2860,29 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsPlayResPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsAmf0Object* args = SrsAmf0Any::object();
-    
+
     SrsPlayResPacket* pkt = new SrsPlayResPacket();
     pkt->command_name = "_result";
     pkt->command_object = SrsAmf0Any::null();
     pkt->desc = args;
-    
+
     args->set("stream" , SrsAmf0Any::str("livestream"));
     args->set("start" , SrsAmf0Any::number(0));
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x14,
-        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x07, 0x5f,
-        0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
-        0x03, 0x00, 0x06, 0x73, 0x74, 0x72, 0x65, 0x61,
-        0x6d, 0x02, 0x00, 0x0a, 0x6c, 0x69, 0x76, 0x65,
-        0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x00, 0x05,
-        0x73, 0x74, 0x61, 0x72, 0x74, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x09
+            0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x14,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x07, 0x5f,
+            0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+            0x03, 0x00, 0x06, 0x73, 0x74, 0x72, 0x65, 0x61,
+            0x6d, 0x02, 0x00, 0x0a, 0x6c, 0x69, 0x76, 0x65,
+            0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x00, 0x05,
+            0x73, 0x74, 0x61, 0x72, 0x74, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x09
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
 }
@@ -4943,18 +2894,18 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsOnBWDonePacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsOnBWDonePacket* pkt = new SrsOnBWDonePacket();
     pkt->command_name = "onBWDone";
     pkt->args = SrsAmf0Any::null();
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x14,
-        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x08, 0x6f,
-        0x6e, 0x42, 0x57, 0x44, 0x6f, 0x6e, 0x65, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x05
+            0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x14,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x08, 0x6f,
+            0x6e, 0x42, 0x57, 0x44, 0x6f, 0x6e, 0x65, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x05
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
 }
@@ -4966,29 +2917,29 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsOnStatusCallPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsAmf0Object* args = SrsAmf0Any::object();
-    
+
     args->set("stream" , SrsAmf0Any::str("livestream"));
     args->set("start" , SrsAmf0Any::number(0));
-    
+
     SrsOnStatusCallPacket* pkt = new SrsOnStatusCallPacket();
     pkt->command_name = "onStatus";
     pkt->args = SrsAmf0Any::null();
     pkt->data = args;
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x14,
-        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x08, 0x6f,
-        0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x05, 0x03, 0x00, 0x06, 0x73, 0x74, 0x72, 0x65,
-        0x61, 0x6d, 0x02, 0x00, 0x0a, 0x6c, 0x69, 0x76,
-        0x65, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x00,
-        0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x09
+            0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x14,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x08, 0x6f,
+            0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x05, 0x03, 0x00, 0x06, 0x73, 0x74, 0x72, 0x65,
+            0x61, 0x6d, 0x02, 0x00, 0x0a, 0x6c, 0x69, 0x76,
+            0x65, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x00,
+            0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x09
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
 }
@@ -5000,26 +2951,26 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsOnStatusDataPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsAmf0Object* args = SrsAmf0Any::object();
-    
+
     args->set("stream" , SrsAmf0Any::str("livestream"));
     args->set("start" , SrsAmf0Any::number(0));
-    
+
     SrsOnStatusDataPacket* pkt = new SrsOnStatusDataPacket();
     pkt->command_name = "onData";
     pkt->data = args;
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x12,
-        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x06, 0x6f,
-        0x6e, 0x44, 0x61, 0x74, 0x61, 0x03, 0x00, 0x06,
-        0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x02, 0x00,
-        0x0a, 0x6c, 0x69, 0x76, 0x65, 0x73, 0x74, 0x72,
-        0x65, 0x61, 0x6d, 0x00, 0x05, 0x73, 0x74, 0x61,
-        0x72, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x09
+            0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x12,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x06, 0x6f,
+            0x6e, 0x44, 0x61, 0x74, 0x61, 0x03, 0x00, 0x06,
+            0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x02, 0x00,
+            0x0a, 0x6c, 0x69, 0x76, 0x65, 0x73, 0x74, 0x72,
+            0x65, 0x61, 0x6d, 0x00, 0x05, 0x73, 0x74, 0x61,
+            0x72, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x09
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
 }
@@ -5031,19 +2982,19 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsSampleAccessPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsSampleAccessPacket* pkt = new SrsSampleAccessPacket();
     pkt->command_name = "|RtmpSampleAccess";
     pkt->video_sample_access = true;
     pkt->audio_sample_access = true;
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x12,
-        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x11, 0x7c,
-        0x52, 0x74, 0x6d, 0x70, 0x53, 0x61, 0x6d, 0x70,
-        0x6c, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73,
-        0x01, 0x01, 0x01, 0x01
+            0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x12,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x11, 0x7c,
+            0x52, 0x74, 0x6d, 0x70, 0x53, 0x61, 0x6d, 0x70,
+            0x6c, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73,
+            0x01, 0x01, 0x01, 0x01
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
 }
@@ -5055,26 +3006,26 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsOnMetaDataPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsAmf0Object* args = SrsAmf0Any::object();
-    
+
     args->set("width" , SrsAmf0Any::number(1024));
     args->set("height" , SrsAmf0Any::number(576));
-    
+
     SrsOnMetaDataPacket* pkt = new SrsOnMetaDataPacket();
     pkt->name = "onMetaData";
     pkt->metadata = args;
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     uint8_t buf[] = {
-        0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x12,
-        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0a, 0x6f,
-        0x6e, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74,
-        0x61, 0x03, 0x00, 0x05, 0x77, 0x69, 0x64, 0x74,
-        0x68, 0x00, 0x40, 0x90, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x06, 0x68, 0x65, 0x69, 0x67,
-        0x68, 0x74, 0x00, 0x40, 0x82, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x09
+            0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x12,
+            0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0a, 0x6f,
+            0x6e, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74,
+            0x61, 0x03, 0x00, 0x05, 0x77, 0x69, 0x64, 0x74,
+            0x68, 0x00, 0x40, 0x90, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x06, 0x68, 0x65, 0x69, 0x67,
+            0x68, 0x74, 0x00, 0x40, 0x82, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x09
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), (char*)buf, sizeof(buf)));
 }
@@ -5086,14 +3037,14 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsSetWindowAckSizePacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsSetWindowAckSizePacket* pkt = new SrsSetWindowAckSizePacket();
     pkt->ackowledgement_window_size = 102400;
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     uint8_t buf[] = {
-        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x90, 0x00
+            0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x90, 0x00
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), (char*)buf, sizeof(buf)));
 }
@@ -5105,14 +3056,14 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsAcknowledgementPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsAcknowledgementPacket* pkt = new SrsAcknowledgementPacket();
     pkt->sequence_number = 1024;
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x03,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00
+            0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x03,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
 }
@@ -5124,14 +3075,14 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsSetChunkSizePacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsSetChunkSizePacket* pkt = new SrsSetChunkSizePacket();
     pkt->chunk_size = 1024;
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00
+            0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
 }
@@ -5143,16 +3094,16 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsSetPeerBandwidthPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsSetPeerBandwidthPacket* pkt = new SrsSetPeerBandwidthPacket();
     pkt->type = SrsPeerBandwidthSoft;
     pkt->bandwidth = 1024;
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x06,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
-        0x01
+            0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x06,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
+            0x01
     };
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
 }
@@ -5164,19 +3115,19 @@ VOID TEST(ProtocolStackTest, ProtocolSendSrsUserControlPacket)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     SrsUserControlPacket* pkt = new SrsUserControlPacket();
     pkt->event_type = SrcPCUCSetBufferLength;
     pkt->event_data = 0x01;
     pkt->extra_data = 0x10;
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     char buf[] = {
-        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x04,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
-        0x00, 0x01, 0x00, 0x00, 0x00, 0x10
+            0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x04,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+            0x00, 0x01, 0x00, 0x00, 0x00, 0x10
     };
-    
+
     EXPECT_TRUE(srs_bytes_equals(bio.out_buffer.bytes(), buf, sizeof(buf)));
     EXPECT_TRUE(true);
 }
@@ -5191,39 +3142,39 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVMessageFmtInvalid)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // video message
     uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x03,
-        0x00, 0x00, 0x00, // timestamp
-        0x00, 0x01, 0x10, // length, 272
-        0x09, // message_type
-        0x00, 0x00, 0x00, 0x00, // stream_id
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        0x03, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0xC3, /*next chunk.*/
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x03,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            0x03, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xC3, /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
     };
     bio.in_buffer.append((char*)data, sizeof(data));
-    
+
     SrsCommonMessage* msg = NULL;
     EXPECT_FALSE(ERROR_SUCCESS == proto.recv_message(&msg));
 }
@@ -5235,34 +3186,34 @@ VOID TEST(ProtocolStackTest, ProtocolAckSizeFlow)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     if (true) {
         SrsSetWindowAckSizePacket* pkt = new SrsSetWindowAckSizePacket();
         pkt->ackowledgement_window_size = 512;
-        
+
         EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_packet(pkt, 0));
     }
-    
+
     if (true) {
         SrsCommonMessage* msg = new SrsCommonMessage();
         msg->header.payload_length = msg->size = 4096;
         msg->payload = new char[msg->size];
-        
+
         msg->header.message_type = 9;
         EXPECT_TRUE(msg->header.is_video());
-    
+
         SrsSharedPtrMessage m;
         ASSERT_TRUE(ERROR_SUCCESS == m.create(msg));
 
         EXPECT_TRUE(ERROR_SUCCESS == proto.send_and_free_message(m.copy(), 1));
     }
-    
+
     // copy output to input
     if (true) {
         bio.in_buffer.append(bio.out_buffer.bytes(), bio.out_buffer.length());
         bio.out_buffer.erase(bio.out_buffer.length());
     }
-    
+
     // recv SrsSetWindowAckSizePacket
     if (true) {
         SrsCommonMessage* msg = NULL;
@@ -5277,7 +3228,7 @@ VOID TEST(ProtocolStackTest, ProtocolAckSizeFlow)
         SrsAutoFree(SrsCommonMessage, msg);
         ASSERT_TRUE(msg->header.is_video());
     }
-    
+
     // copy output to input
     if (true) {
         bio.in_buffer.append(bio.out_buffer.bytes(), bio.out_buffer.length());
@@ -5290,16 +3241,16 @@ VOID TEST(ProtocolStackTest, ProtocolAckSizeFlow)
         SrsAutoFree(SrsCommonMessage, msg);
         ASSERT_TRUE(msg->header.is_ackledgement());
     }
-    
+
     // send again
     if (true) {
         SrsCommonMessage* msg = new SrsCommonMessage();
         msg->header.payload_length = msg->size = 4096;
         msg->payload = new char[msg->size];
-        
+
         msg->header.message_type = 9;
         EXPECT_TRUE(msg->header.is_video());
-    
+
         SrsSharedPtrMessage m;
         ASSERT_TRUE(ERROR_SUCCESS == m.create(msg));
 
@@ -5317,7 +3268,7 @@ VOID TEST(ProtocolStackTest, ProtocolAckSizeFlow)
         SrsAutoFree(SrsCommonMessage, msg);
         ASSERT_TRUE(msg->header.is_video());
     }
-    
+
     // copy output to input
     if (true) {
         bio.in_buffer.append(bio.out_buffer.bytes(), bio.out_buffer.length());
@@ -5339,7 +3290,7 @@ VOID TEST(ProtocolStackTest, ProtocolPingFlow)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // ping request
     if (true) {
         SrsUserControlPacket* pkt = new SrsUserControlPacket();
@@ -5359,7 +3310,7 @@ VOID TEST(ProtocolStackTest, ProtocolPingFlow)
         SrsAutoFree(SrsCommonMessage, msg);
         EXPECT_TRUE(msg->header.is_user_control_message());
     }
-    
+
     // recv the server auto send ping response message
     // copy output to input
     if (true) {
@@ -5372,12 +3323,12 @@ VOID TEST(ProtocolStackTest, ProtocolPingFlow)
         ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
         SrsAutoFree(SrsCommonMessage, msg);
         ASSERT_TRUE(msg->header.is_user_control_message());
-        
+
         SrsPacket* pkt = NULL;
         ASSERT_TRUE(ERROR_SUCCESS == proto.decode_message(msg, &pkt));
         SrsUserControlPacket* spkt = dynamic_cast<SrsUserControlPacket*>(pkt);
         ASSERT_TRUE(spkt != NULL);
-        
+
         EXPECT_TRUE(SrcPCUCPingResponse == spkt->event_type);
         EXPECT_TRUE(0x3456 == spkt->event_data);
     }
@@ -5390,45 +3341,45 @@ VOID TEST(ProtocolStackTest, ProtocolExcpectMessage)
 {
     MockBufferIO bio;
     SrsProtocol proto(&bio);
-    
+
     // packet is SrsConnectAppPacket
     uint8_t data[] = {
-        // 12bytes header, 1byts chunk header, 11bytes msg heder
-        0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0xa1, 0x14, 0x00, 0x00, 0x00, 0x00,
-        // msg payload start
-        0x02, 0x00, 0x07, 0x63,
-        0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-        0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
-        0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
-        0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
-        0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
-        0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
-        0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-        0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
-        0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
-        0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
-        0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
-        0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
-        0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
-        0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
-        0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0xC3, /*next chunk.*/         0x0d, 0x76, 0x69, 0x64,
-        0x65, 0x6f, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x61, 0x67, 0x65, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x62, 0x68,
-        0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72, 0x73, 0x2e,
-        0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73,
-        0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x68, 0x74, 0x6d, 0x6c,
-        0x3f, 0x76, 0x68, 0x6f, 0x73, 0x74, 0x3d, 0x64, 0x65, 0x76, 0x26, 0x73, 0x74, 0x72, 0x65, 0x61,
-        0x6d, 0x3d, 0x6c, 0x69, 0x76, 0x65, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x26, 0x73, 0x65, 0x72,
-        0x76, 0x65, 0x72, 0x3d, 0x64, 0x65, 0x76, 0x26, 0x70, 0x6f, 0x72, 0x74,
-        0xC3, /*next chunk.*/         0x3d, 0x31, 0x39, 0x33,
-        0x35, 0x00, 0x0e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e,
-        0x67, 0x00, 0x40, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0xa1, 0x14, 0x00, 0x00, 0x00, 0x00,
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xC3, /*next chunk.*/         0x0d, 0x76, 0x69, 0x64,
+            0x65, 0x6f, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x61, 0x67, 0x65, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x62, 0x68,
+            0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72, 0x73, 0x2e,
+            0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73,
+            0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x68, 0x74, 0x6d, 0x6c,
+            0x3f, 0x76, 0x68, 0x6f, 0x73, 0x74, 0x3d, 0x64, 0x65, 0x76, 0x26, 0x73, 0x74, 0x72, 0x65, 0x61,
+            0x6d, 0x3d, 0x6c, 0x69, 0x76, 0x65, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x26, 0x73, 0x65, 0x72,
+            0x76, 0x65, 0x72, 0x3d, 0x64, 0x65, 0x76, 0x26, 0x70, 0x6f, 0x72, 0x74,
+            0xC3, /*next chunk.*/         0x3d, 0x31, 0x39, 0x33,
+            0x35, 0x00, 0x0e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e,
+            0x67, 0x00, 0x40, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09
     };
     bio.in_buffer.append((char*)data, sizeof(data));
-    
+
     SrsCommonMessage* msg = NULL;
     SrsConnectAppPacket* pkt = NULL;
     ASSERT_TRUE(ERROR_SUCCESS == proto.expect_message<SrsConnectAppPacket>(&msg, &pkt));
@@ -5441,47 +3392,47 @@ VOID TEST(ProtocolRTMPTest, RTMPRequest)
 {
     SrsRequest req;
     std::string param;
-    
+
     req.stream = "livestream";
-    srs_discovery_tc_url("rtmp://std.ossrs.net/live", 
-        req.schema, req.host, req.vhost, req.app, req.stream, req.port, param);
+    srs_discovery_tc_url("rtmp://std.ossrs.net/live",
+                         req.schema, req.host, req.vhost, req.app, req.stream, req.port, param);
     req.strip();
     EXPECT_STREQ("rtmp", req.schema.c_str());
     EXPECT_STREQ("std.ossrs.net", req.host.c_str());
     EXPECT_STREQ("std.ossrs.net", req.vhost.c_str());
     EXPECT_STREQ("live", req.app.c_str());
     EXPECT_EQ(1935, req.port);
-    
+
     req.stream = "livestream";
-    srs_discovery_tc_url("rtmp://s td.os srs.n et/li v e", 
-        req.schema, req.host, req.vhost, req.app, req.stream, req.port, param);
+    srs_discovery_tc_url("rtmp://s td.os srs.n et/li v e",
+                         req.schema, req.host, req.vhost, req.app, req.stream, req.port, param);
     req.strip();
     EXPECT_STREQ("rtmp", req.schema.c_str());
     EXPECT_STREQ("std.ossrs.net", req.host.c_str());
     EXPECT_STREQ("std.ossrs.net", req.vhost.c_str());
     EXPECT_STREQ("live", req.app.c_str());
     EXPECT_EQ(1935, req.port);
-    
+
     req.stream = "livestream";
-    srs_discovery_tc_url("rtmp://s\ntd.o\rssrs.ne\nt/li\nve", 
-        req.schema, req.host, req.vhost, req.app, req.stream, req.port, param);
+    srs_discovery_tc_url("rtmp://s\ntd.o\rssrs.ne\nt/li\nve",
+                         req.schema, req.host, req.vhost, req.app, req.stream, req.port, param);
     req.strip();
     EXPECT_STREQ("rtmp", req.schema.c_str());
     EXPECT_STREQ("std.ossrs.net", req.host.c_str());
     EXPECT_STREQ("std.ossrs.net", req.vhost.c_str());
     EXPECT_STREQ("live", req.app.c_str());
     EXPECT_EQ(1935, req.port);
-    
+
     req.stream = "livestream";
-    srs_discovery_tc_url("rtmp://std.ossrs.net/live ", 
-        req.schema, req.host, req.vhost, req.app, req.stream, req.port, param);
+    srs_discovery_tc_url("rtmp://std.ossrs.net/live ",
+                         req.schema, req.host, req.vhost, req.app, req.stream, req.port, param);
     req.strip();
     EXPECT_STREQ("rtmp", req.schema.c_str());
     EXPECT_STREQ("std.ossrs.net", req.host.c_str());
     EXPECT_STREQ("std.ossrs.net", req.vhost.c_str());
     EXPECT_STREQ("live", req.app.c_str());
     EXPECT_EQ(1935, req.port);
-    
+
     EXPECT_TRUE(NULL == req.args);
     SrsRequest req1;
     req1.args = SrsAmf0Any::object();
@@ -5494,59 +3445,59 @@ VOID TEST(ProtocolRTMPTest, RTMPHandshakeBytes)
 {
     MockBufferIO bio;
     SrsHandshakeBytes bytes;
-    
+
     char hs[3073];
     bio.in_buffer.append(hs, sizeof(hs));
     bio.in_buffer.append(hs, sizeof(hs));
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == bytes.read_c0c1(&bio));
     EXPECT_TRUE(bytes.c0c1 != NULL);
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == bytes.read_c2(&bio));
     EXPECT_TRUE(bytes.c2 != NULL);
-    
+
     EXPECT_TRUE(ERROR_SUCCESS == bytes.read_s0s1s2(&bio));
     EXPECT_TRUE(bytes.s0s1s2 != NULL);
 }
 
 struct MockStage
 {
-	http_parser parser;
-	const char* at;
-	size_t length;
+    http_parser parser;
+    const char* at;
+    size_t length;
 
-	MockStage(http_parser* from);
+    MockStage(http_parser* from);
 };
 
 MockStage::MockStage(http_parser* from)
 {
-	parser = *from;
-	at = NULL;
-	length = 0;
+    parser = *from;
+    at = NULL;
+    length = 0;
 }
 
 class MockParser
 {
 private:
-	http_parser_settings settings;
-	http_parser* parser;
-	size_t parsed;
+    http_parser_settings settings;
+    http_parser* parser;
+    size_t parsed;
 public:
-	MockStage* message_begin;
-	MockStage* url;
-	MockStage* status;
-	MockStage* header_field;
-	MockStage* header_value;
-	MockStage* headers_complete;
-	MockStage* body;
-	MockStage* message_complete;
-	MockStage* chunk_header;
-	MockStage* chunk_complete;
+    MockStage* message_begin;
+    MockStage* url;
+    MockStage* status;
+    MockStage* header_field;
+    MockStage* header_value;
+    MockStage* headers_complete;
+    MockStage* body;
+    MockStage* message_complete;
+    MockStage* chunk_header;
+    MockStage* chunk_complete;
 public:
-	MockParser();
-	virtual ~MockParser();
+    MockParser();
+    virtual ~MockParser();
 public:
-	srs_error_t parse(string data);
+    srs_error_t parse(string data);
 private:
     static int on_message_begin(http_parser* parser);
     static int on_url(http_parser* parser, const char* at, size_t length);
@@ -5562,8 +3513,8 @@ private:
 
 MockParser::MockParser()
 {
-	parser = new http_parser();
-	http_parser_init(parser, HTTP_REQUEST);
+    parser = new http_parser();
+    http_parser_init(parser, HTTP_REQUEST);
     parser->data = (void*)this;
     parsed = 0;
 
@@ -5579,32 +3530,32 @@ MockParser::MockParser()
     settings.on_chunk_header = on_chunk_header;
     settings.on_chunk_complete = on_chunk_complete;
 
-	message_begin = NULL;
-	url = NULL;
-	status = NULL;
-	header_field = NULL;
-	header_value = NULL;
-	headers_complete = NULL;
-	body = NULL;
-	message_complete = NULL;
-	chunk_header = NULL;
-	chunk_complete = NULL;
+    message_begin = NULL;
+    url = NULL;
+    status = NULL;
+    header_field = NULL;
+    header_value = NULL;
+    headers_complete = NULL;
+    body = NULL;
+    message_complete = NULL;
+    chunk_header = NULL;
+    chunk_complete = NULL;
 }
 
 MockParser::~MockParser()
 {
-	srs_freep(parser);
+    srs_freep(parser);
 
-	srs_freep(message_begin);
-	srs_freep(url);
-	srs_freep(status);
-	srs_freep(header_field);
-	srs_freep(header_value);
-	srs_freep(headers_complete);
-	srs_freep(body);
-	srs_freep(message_complete);
-	srs_freep(chunk_header);
-	srs_freep(chunk_complete);
+    srs_freep(message_begin);
+    srs_freep(url);
+    srs_freep(status);
+    srs_freep(header_field);
+    srs_freep(header_value);
+    srs_freep(headers_complete);
+    srs_freep(body);
+    srs_freep(message_complete);
+    srs_freep(chunk_header);
+    srs_freep(chunk_complete);
 }
 
 int MockParser::on_message_begin(http_parser* parser)
@@ -5612,7 +3563,7 @@ int MockParser::on_message_begin(http_parser* parser)
     MockParser* obj = (MockParser*)parser->data;
     srs_assert(obj);
 
-	srs_freep(obj->message_begin);
+    srs_freep(obj->message_begin);
     obj->message_begin = new MockStage(parser);
 
     return 0;
@@ -5623,7 +3574,7 @@ int MockParser::on_url(http_parser* parser, const char* at, size_t length)
     MockParser* obj = (MockParser*)parser->data;
     srs_assert(obj);
 
-	srs_freep(obj->url);
+    srs_freep(obj->url);
     obj->url = new MockStage(parser);
     obj->url->at = at;
     obj->url->length = length;
@@ -5636,7 +3587,7 @@ int MockParser::on_status(http_parser* parser, const char* at, size_t length)
     MockParser* obj = (MockParser*)parser->data;
     srs_assert(obj);
 
-	srs_freep(obj->status);
+    srs_freep(obj->status);
     obj->status = new MockStage(parser);
     obj->status->at = at;
     obj->status->length = length;
@@ -5649,7 +3600,7 @@ int MockParser::on_header_field(http_parser* parser, const char* at, size_t leng
     MockParser* obj = (MockParser*)parser->data;
     srs_assert(obj);
 
-	srs_freep(obj->header_field);
+    srs_freep(obj->header_field);
     obj->header_field = new MockStage(parser);
     obj->header_field->at = at;
     obj->header_field->length = length;
@@ -5662,7 +3613,7 @@ int MockParser::on_header_value(http_parser* parser, const char* at, size_t leng
     MockParser* obj = (MockParser*)parser->data;
     srs_assert(obj);
 
-	srs_freep(obj->header_value);
+    srs_freep(obj->header_value);
     obj->header_value = new MockStage(parser);
     obj->header_value->at = at;
     obj->header_value->length = length;
@@ -5675,7 +3626,7 @@ int MockParser::on_headers_complete(http_parser* parser)
     MockParser* obj = (MockParser*)parser->data;
     srs_assert(obj);
 
-	srs_freep(obj->headers_complete);
+    srs_freep(obj->headers_complete);
     obj->headers_complete = new MockStage(parser);
 
     return 0;
@@ -5686,7 +3637,7 @@ int MockParser::on_body(http_parser* parser, const char* at, size_t length)
     MockParser* obj = (MockParser*)parser->data;
     srs_assert(obj);
 
-	srs_freep(obj->body);
+    srs_freep(obj->body);
     obj->body = new MockStage(parser);
     obj->body->at = at;
     obj->body->length = length;
@@ -5699,7 +3650,7 @@ int MockParser::on_message_complete(http_parser* parser)
     MockParser* obj = (MockParser*)parser->data;
     srs_assert(obj);
 
-	srs_freep(obj->message_complete);
+    srs_freep(obj->message_complete);
     obj->message_complete = new MockStage(parser);
 
     return 0;
@@ -5710,7 +3661,7 @@ int MockParser::on_chunk_header(http_parser* parser)
     MockParser* obj = (MockParser*)parser->data;
     srs_assert(obj);
 
-	srs_freep(obj->chunk_header);
+    srs_freep(obj->chunk_header);
     obj->chunk_header = new MockStage(parser);
 
     return 0;
@@ -5721,7 +3672,7 @@ int MockParser::on_chunk_complete(http_parser* parser)
     MockParser* obj = (MockParser*)parser->data;
     srs_assert(obj);
 
-	srs_freep(obj->chunk_complete);
+    srs_freep(obj->chunk_complete);
     obj->chunk_complete = new MockStage(parser);
 
     return 0;
@@ -5729,221 +3680,221 @@ int MockParser::on_chunk_complete(http_parser* parser)
 
 srs_error_t MockParser::parse(string data)
 {
-	srs_error_t err = srs_success;
+    srs_error_t err = srs_success;
 
-	const char* buf = (const char*)data.data();
-	size_t size = (size_t)data.length();
-	size_t nparsed = http_parser_execute(parser, &settings, buf, size);
-	parsed = nparsed;
+    const char* buf = (const char*)data.data();
+    size_t size = (size_t)data.length();
+    size_t nparsed = http_parser_execute(parser, &settings, buf, size);
+    parsed = nparsed;
 
-	if (nparsed != size) {
-		return srs_error_new(-1, "nparsed=%d, size=%d", nparsed, size);
-	}
+    if (nparsed != size) {
+        return srs_error_new(-1, "nparsed=%d, size=%d", nparsed, size);
+    }
 
-	return err;
+    return err;
 }
 
 VOID TEST(ProtocolHTTPTest, HTTPParser)
 {
-	srs_error_t err;
+    srs_error_t err;
 
-	if (true) {
-		MockParser parser;
-		// size = 70, nparsed = 70, nread = 0
-		HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\n"));
-		EXPECT_EQ(70, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-		EXPECT_TRUE(!parser.body);
-		EXPECT_TRUE(parser.headers_complete);
-		EXPECT_TRUE(!parser.message_complete);
-	}
+    if (true) {
+        MockParser parser;
+        // size = 70, nparsed = 70, nread = 0
+        HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\n"));
+        EXPECT_EQ(70, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+        EXPECT_TRUE(!parser.body);
+        EXPECT_TRUE(parser.headers_complete);
+        EXPECT_TRUE(!parser.message_complete);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 75, nparsed = 75, nread = 0
-		HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nHello"));
-		EXPECT_EQ(75, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-		EXPECT_TRUE(parser.body && 5 == parser.body->length);
-		EXPECT_TRUE(parser.headers_complete);
-		EXPECT_TRUE(parser.message_complete);
-	}
+    if (true) {
+        MockParser parser;
+        // size = 75, nparsed = 75, nread = 0
+        HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nHello"));
+        EXPECT_EQ(75, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+        EXPECT_TRUE(parser.body && 5 == parser.body->length);
+        EXPECT_TRUE(parser.headers_complete);
+        EXPECT_TRUE(parser.message_complete);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 150, nparsed = 150, nread = 0
-		HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nHelloGET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nWorld"));
-		EXPECT_EQ(150, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-	}
+    if (true) {
+        MockParser parser;
+        // size = 150, nparsed = 150, nread = 0
+        HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nHelloGET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nWorld"));
+        EXPECT_EQ(150, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 70, nparsed = 70, nread = 0, content_length = 5, Header("Content-Length", 5)
-		HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\n"));
-		EXPECT_EQ(70, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-		EXPECT_EQ(5, (int)parser.parser->content_length);
+    if (true) {
+        MockParser parser;
+        // size = 70, nparsed = 70, nread = 0, content_length = 5, Header("Content-Length", 5)
+        HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\n"));
+        EXPECT_EQ(70, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+        EXPECT_EQ(5, (int)parser.parser->content_length);
 
-		// size = 79, nparsed = 5, nread = 1, content_length = -1, Header("Content-Length", 5)
-		HELPER_EXPECT_FAILED(parser.parse("elloGET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nHello"));
-		EXPECT_EQ(5, (int)parser.parsed);
-		EXPECT_EQ(1, (int)parser.parser->nread);
-		EXPECT_EQ(-1, (int64_t)parser.parser->content_length);
-	}
+        // size = 79, nparsed = 5, nread = 1, content_length = -1, Header("Content-Length", 5)
+        HELPER_EXPECT_FAILED(parser.parse("elloGET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nHello"));
+        EXPECT_EQ(5, (int)parser.parsed);
+        EXPECT_EQ(1, (int)parser.parser->nread);
+        EXPECT_EQ(-1, (int64_t)parser.parser->content_length);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 70, nparsed = 70, nread = 0, content_length = 5, Header("Content-Length", 5)
-		HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\n"));
-		EXPECT_EQ(70, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-		EXPECT_EQ(5, (int)parser.parser->content_length);
+    if (true) {
+        MockParser parser;
+        // size = 70, nparsed = 70, nread = 0, content_length = 5, Header("Content-Length", 5)
+        HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\n"));
+        EXPECT_EQ(70, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+        EXPECT_EQ(5, (int)parser.parser->content_length);
 
-		// size = 80, nparsed = 70, nread = 0, content_length = 0, Header("Content-Length", 5)
-		HELPER_EXPECT_SUCCESS(parser.parse("HelloGET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nWorld"));
-		EXPECT_EQ(80, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-		EXPECT_EQ(0, (int)parser.parser->content_length);
-	}
+        // size = 80, nparsed = 70, nread = 0, content_length = 0, Header("Content-Length", 5)
+        HELPER_EXPECT_SUCCESS(parser.parse("HelloGET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nWorld"));
+        EXPECT_EQ(80, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+        EXPECT_EQ(0, (int)parser.parser->content_length);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 73, nparsed = 73, nread = 0, content_length = 2, Header("Content-Length", 5)
-		HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nHel"));
-		EXPECT_EQ(73, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-		EXPECT_EQ(2, (int)parser.parser->content_length);
-	}
+    if (true) {
+        MockParser parser;
+        // size = 73, nparsed = 73, nread = 0, content_length = 2, Header("Content-Length", 5)
+        HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nHel"));
+        EXPECT_EQ(73, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+        EXPECT_EQ(2, (int)parser.parser->content_length);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 82, nparsed = 75, nread = 1, content_length = -1, Header("Content-Length", 5)
-		HELPER_EXPECT_FAILED(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nHello World!"));
-		EXPECT_EQ(75, (int)parser.parsed);
-		EXPECT_EQ(1, (int)parser.parser->nread);
-		EXPECT_EQ(-1, (int64_t)parser.parser->content_length);
-	}
+    if (true) {
+        MockParser parser;
+        // size = 82, nparsed = 75, nread = 1, content_length = -1, Header("Content-Length", 5)
+        HELPER_EXPECT_FAILED(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nHello World!"));
+        EXPECT_EQ(75, (int)parser.parsed);
+        EXPECT_EQ(1, (int)parser.parser->nread);
+        EXPECT_EQ(-1, (int64_t)parser.parser->content_length);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 34, nparsed = 34, nread = 34
-		HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHo"));
-		EXPECT_EQ(34, (int)parser.parsed);
-		EXPECT_EQ(34, (int)parser.parser->nread);
+    if (true) {
+        MockParser parser;
+        // size = 34, nparsed = 34, nread = 34
+        HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHo"));
+        EXPECT_EQ(34, (int)parser.parsed);
+        EXPECT_EQ(34, (int)parser.parser->nread);
 
-		// size = 41, nparsed = 41, nread = 0
-		HELPER_EXPECT_SUCCESS(parser.parse("st: ossrs.net\r\nContent-Length: 5\r\n\r\nHello"));
-		EXPECT_EQ(41, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-	}
+        // size = 41, nparsed = 41, nread = 0
+        HELPER_EXPECT_SUCCESS(parser.parse("st: ossrs.net\r\nContent-Length: 5\r\n\r\nHello"));
+        EXPECT_EQ(41, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 41, nparsed = 41, nread = 41
-		HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: oss"));
-		EXPECT_EQ(41, (int)parser.parsed);
-		EXPECT_EQ(41, (int)parser.parser->nread);
+    if (true) {
+        MockParser parser;
+        // size = 41, nparsed = 41, nread = 41
+        HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: oss"));
+        EXPECT_EQ(41, (int)parser.parsed);
+        EXPECT_EQ(41, (int)parser.parser->nread);
 
-		// size = 34, nparsed = 34, nread = 0
-		HELPER_EXPECT_SUCCESS(parser.parse("rs.net\r\nContent-Length: 5\r\n\r\nHello"));
-		EXPECT_EQ(34, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-	}
+        // size = 34, nparsed = 34, nread = 0
+        HELPER_EXPECT_SUCCESS(parser.parse("rs.net\r\nContent-Length: 5\r\n\r\nHello"));
+        EXPECT_EQ(34, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 48, nparsed = 48, nread = 48
-		HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r"));
-		EXPECT_EQ(48, (int)parser.parsed);
-		EXPECT_EQ(48, (int)parser.parser->nread);
+    if (true) {
+        MockParser parser;
+        // size = 48, nparsed = 48, nread = 48
+        HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r"));
+        EXPECT_EQ(48, (int)parser.parsed);
+        EXPECT_EQ(48, (int)parser.parser->nread);
 
-		// size = 27, nparsed = 27, nread = 0
-		HELPER_EXPECT_SUCCESS(parser.parse("\nContent-Length: 5\r\n\r\nHello"));
-		EXPECT_EQ(27, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-	}
+        // size = 27, nparsed = 27, nread = 0
+        HELPER_EXPECT_SUCCESS(parser.parse("\nContent-Length: 5\r\n\r\nHello"));
+        EXPECT_EQ(27, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 68, nparsed = 68, nread = 68
-		HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n"));
-		EXPECT_EQ(68, (int)parser.parsed);
-		EXPECT_EQ(68, (int)parser.parser->nread);
+    if (true) {
+        MockParser parser;
+        // size = 68, nparsed = 68, nread = 68
+        HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n"));
+        EXPECT_EQ(68, (int)parser.parsed);
+        EXPECT_EQ(68, (int)parser.parser->nread);
 
-		// size = 7, nparsed = 7, nread = 0
-		HELPER_EXPECT_SUCCESS(parser.parse("\r\nHello"));
-		EXPECT_EQ(7, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-	}
+        // size = 7, nparsed = 7, nread = 0
+        HELPER_EXPECT_SUCCESS(parser.parse("\r\nHello"));
+        EXPECT_EQ(7, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 69, nparsed = 69, nread = 69
-		HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r"));
-		EXPECT_EQ(69, (int)parser.parsed);
-		EXPECT_EQ(69, (int)parser.parser->nread);
+    if (true) {
+        MockParser parser;
+        // size = 69, nparsed = 69, nread = 69
+        HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r"));
+        EXPECT_EQ(69, (int)parser.parsed);
+        EXPECT_EQ(69, (int)parser.parser->nread);
 
-		// size = 6, nparsed = 6, nread = 0
-		HELPER_EXPECT_SUCCESS(parser.parse("\nHello"));
-		EXPECT_EQ(6, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-	}
+        // size = 6, nparsed = 6, nread = 0
+        HELPER_EXPECT_SUCCESS(parser.parse("\nHello"));
+        EXPECT_EQ(6, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 75, nparsed = 75, nread = 0
-		HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nHello"));
-		EXPECT_EQ(75, (int)parser.parsed);
-		EXPECT_EQ(0, (int)parser.parser->nread);
-	}
+    if (true) {
+        MockParser parser;
+        // size = 75, nparsed = 75, nread = 0
+        HELPER_EXPECT_SUCCESS(parser.parse("GET /gslb/v1/versions HTTP/1.1\r\nHost: ossrs.net\r\nContent-Length: 5\r\n\r\nHello"));
+        EXPECT_EQ(75, (int)parser.parsed);
+        EXPECT_EQ(0, (int)parser.parser->nread);
+    }
 
-	if (true) {
-		MockParser parser;
-		// nparsed = 2, size = 2, nread = 2
-		HELPER_EXPECT_SUCCESS(parser.parse("GE"));
-		EXPECT_EQ(2, (int)parser.parsed);
-		EXPECT_EQ(2, (int)parser.parser->nread);
+    if (true) {
+        MockParser parser;
+        // nparsed = 2, size = 2, nread = 2
+        HELPER_EXPECT_SUCCESS(parser.parse("GE"));
+        EXPECT_EQ(2, (int)parser.parsed);
+        EXPECT_EQ(2, (int)parser.parser->nread);
 
-		// size = 0, nparsed = 1, nread=2
-		HELPER_EXPECT_FAILED(parser.parse(""));
-		EXPECT_EQ(1, (int)parser.parsed);
-		EXPECT_EQ(2, (int)parser.parser->nread);
-	}
+        // size = 0, nparsed = 1, nread=2
+        HELPER_EXPECT_FAILED(parser.parse(""));
+        EXPECT_EQ(1, (int)parser.parsed);
+        EXPECT_EQ(2, (int)parser.parser->nread);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 2, nparsed = 2, nread = 2
-		HELPER_EXPECT_SUCCESS(parser.parse("GE"));
-		EXPECT_EQ(2, (int)parser.parsed);
-		EXPECT_EQ(2, (int)parser.parser->nread);
+    if (true) {
+        MockParser parser;
+        // size = 2, nparsed = 2, nread = 2
+        HELPER_EXPECT_SUCCESS(parser.parse("GE"));
+        EXPECT_EQ(2, (int)parser.parsed);
+        EXPECT_EQ(2, (int)parser.parser->nread);
 
-		// size = 1, nparsed = 0, nread = 3
-		HELPER_EXPECT_FAILED(parser.parse("X"));
-		EXPECT_EQ(0, (int)parser.parsed);
-		EXPECT_EQ(3, (int)parser.parser->nread);
-	}
+        // size = 1, nparsed = 0, nread = 3
+        HELPER_EXPECT_FAILED(parser.parse("X"));
+        EXPECT_EQ(0, (int)parser.parsed);
+        EXPECT_EQ(3, (int)parser.parser->nread);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 2, nparsed = 2, nread = 2
-		HELPER_EXPECT_SUCCESS(parser.parse("GE"));
-		EXPECT_EQ(2, (int)parser.parsed);
-		EXPECT_EQ(2, (int)parser.parser->nread);
+    if (true) {
+        MockParser parser;
+        // size = 2, nparsed = 2, nread = 2
+        HELPER_EXPECT_SUCCESS(parser.parse("GE"));
+        EXPECT_EQ(2, (int)parser.parsed);
+        EXPECT_EQ(2, (int)parser.parser->nread);
 
-		// size = 1, nparsed = 1, nread = 3
-		HELPER_EXPECT_SUCCESS(parser.parse("T"));
-		EXPECT_EQ(1, (int)parser.parsed);
-		EXPECT_EQ(3, (int)parser.parser->nread);
-	}
+        // size = 1, nparsed = 1, nread = 3
+        HELPER_EXPECT_SUCCESS(parser.parse("T"));
+        EXPECT_EQ(1, (int)parser.parsed);
+        EXPECT_EQ(3, (int)parser.parser->nread);
+    }
 
-	if (true) {
-		MockParser parser;
-		// size = 3, nparsed = 3, nread = 3
-		HELPER_EXPECT_SUCCESS(parser.parse("GET"));
-		EXPECT_EQ(3, (int)parser.parsed);
-		EXPECT_EQ(3, (int)parser.parser->nread);
-	}
+    if (true) {
+        MockParser parser;
+        // size = 3, nparsed = 3, nread = 3
+        HELPER_EXPECT_SUCCESS(parser.parse("GET"));
+        EXPECT_EQ(3, (int)parser.parsed);
+        EXPECT_EQ(3, (int)parser.parser->nread);
+    }
 }
 
 VOID TEST(ProtocolHTTPTest, ParseHTTPMessage)
@@ -5965,7 +3916,7 @@ VOID TEST(ProtocolHTTPTest, ParseHTTPMessage)
         EXPECT_FALSE(req->body_reader()->eof());
         srs_freep(req);
 
-		// Got new packet, notice that previous body still exists in bio.
+        // Got new packet, notice that previous body still exists in bio.
         bio.append("GET /gslb/v2/versions HTTP/1.1\r\nContent-Length: 5\r\n\r\nHello");
 
         // Should fail because there is body which not read.
@@ -5981,61 +3932,61 @@ VOID TEST(ProtocolHTTPTest, ParseHTTPMessage)
         bio.append("GET");
         HELPER_ASSERT_SUCCESS(hp.initialize(HTTP_REQUEST));
 
-		// Should fail if not completed message.
+        // Should fail if not completed message.
         ISrsHttpMessage* req = NULL;
         HELPER_ASSERT_FAILED(hp.parse_message(&bio, &req));
         srs_freep(req);
     }
-    
+
     if (true) {
         MockBufferIO bio;
         SrsHttpParser hp;
-        
+
         bio.append("GET /gslb/v1/versions HTTP/1.1\r\nContent-Length: 5\r\n\r\nHello");
         HELPER_ASSERT_SUCCESS(hp.initialize(HTTP_REQUEST));
-        
+
         ISrsHttpMessage* req = NULL;
         SrsAutoFree(ISrsHttpMessage, req);
         HELPER_ASSERT_SUCCESS(hp.parse_message(&bio, &req));
-        
+
         char v[64] = {0};
         HELPER_ASSERT_SUCCESS(req->body_reader()->read(v, sizeof(v), NULL));
         EXPECT_TRUE(string("Hello") == string(v));
-        
+
         EXPECT_TRUE(req->body_reader()->eof());
     }
-    
+
     if (true) {
         MockBufferIO bio;
         SrsHttpParser hp;
-        
+
         bio.append("GET /gslb/v1/versions HTTP/1.1\r\nContent-Length: 0\r\n\r\n");
         HELPER_ASSERT_SUCCESS(hp.initialize(HTTP_REQUEST));
-        
+
         ISrsHttpMessage* req = NULL;
         SrsAutoFree(ISrsHttpMessage, req);
         HELPER_ASSERT_SUCCESS(hp.parse_message(&bio, &req));
     }
-    
+
     if (true) {
         MockBufferIO bio;
         SrsHttpParser hp;
-        
+
         bio.append("GET /gslb/v1/versions HTTP/1.1\r\n\r\n");
         HELPER_ASSERT_SUCCESS(hp.initialize(HTTP_REQUEST));
-        
+
         ISrsHttpMessage* req = NULL;
         SrsAutoFree(ISrsHttpMessage, req);
         HELPER_ASSERT_SUCCESS(hp.parse_message(&bio, &req));
     }
-    
+
     if (true) {
         MockBufferIO bio;
         SrsHttpParser hp;
-        
+
         bio.append("GET /gslb/v1/versions HTTP/1.1\r\n\r\n");
         HELPER_ASSERT_SUCCESS(hp.initialize(HTTP_REQUEST));
-        
+
         ISrsHttpMessage* req = NULL;
         SrsAutoFree(ISrsHttpMessage, req);
         HELPER_ASSERT_SUCCESS(hp.parse_message(&bio, &req));
@@ -6338,3 +4289,2737 @@ VOID TEST(ProtocolKbpsTest, NewDelta)
     }
 }
 
+/**
+* recv video, audio, video and video, interlaced in chunks.
+*/
+VOID TEST(ProtocolStackTest, ProtocolRecvVAVVMessage)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x03,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x04,
+                0x00, 0x00, 0x15, // timestamp
+                0x00, 0x00, 0x90, // length, 144
+                0x08, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x03,
+                0x00, 0x00, 0x20, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC4, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x03,
+                0x00, 0x00, 0x30, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x10, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_audio());
+        EXPECT_EQ(0x15, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x20, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x30, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+}
+
+/**
+* recv video, audio, video and video, interlaced in chunks.
+* the continue chunks use fmt=1 header
+*/
+VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt1)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    /**
+    * parse the message header.
+    *   3bytes: timestamp delta,    fmt=0,1,2
+    *   3bytes: payload length,     fmt=0,1
+    *   1bytes: message type,       fmt=0,1
+    *   4bytes: stream id,          fmt=0
+    * where:
+    *   fmt=0, 0x0X
+    *   fmt=1, 0x4X
+    *   fmt=2, 0x8X
+    *   fmt=3, 0xCX
+    */
+
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x03,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x04,
+                0x00, 0x00, 0x15, // timestamp
+                0x00, 0x00, 0x90, // length, 144
+                0x08, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x43,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC4, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x43,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x10, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_audio());
+        EXPECT_EQ(0x15, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x20, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x30, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+}
+
+/**
+* recv video, audio, video and video, interlaced in chunks.
+* the continue chunks use fmt=2 header
+*/
+VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt2)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    /**
+    * parse the message header.
+    *   3bytes: timestamp delta,    fmt=0,1,2
+    *   3bytes: payload length,     fmt=0,1
+    *   1bytes: message type,       fmt=0,1
+    *   4bytes: stream id,          fmt=0
+    * where:
+    *   fmt=0, 0x0X
+    *   fmt=1, 0x4X
+    *   fmt=2, 0x8X
+    *   fmt=3, 0xCX
+    */
+
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x03,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x04,
+                0x00, 0x00, 0x15, // timestamp
+                0x00, 0x00, 0x90, // length, 144
+                0x08, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x83,
+                0x00, 0x00, 0x10, // timestamp
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC4, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x83,
+                0x00, 0x00, 0x10, // timestamp
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x10, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_audio());
+        EXPECT_EQ(0x15, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x20, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x30, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+}
+
+/**
+* recv video, audio, video and video, interlaced in chunks.
+* the continue chunks use fmt=3 header
+*/
+VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt3)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    /**
+    * parse the message header.
+    *   3bytes: timestamp delta,    fmt=0,1,2
+    *   3bytes: payload length,     fmt=0,1
+    *   1bytes: message type,       fmt=0,1
+    *   4bytes: stream id,          fmt=0
+    * where:
+    *   fmt=0, 0x0X
+    *   fmt=1, 0x4X
+    *   fmt=2, 0x8X
+    *   fmt=3, 0xCX
+    */
+
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x03,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x04,
+                0x00, 0x00, 0x15, // timestamp
+                0x00, 0x00, 0x90, // length, 144
+                0x08, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0xC3,
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC4, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0xC3,
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x10, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_audio());
+        EXPECT_EQ(0x15, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x20, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x30, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+}
+
+/**
+* recv video, audio, video and video, interlaced in chunks.
+* the continue chunks use fmt=1, last video with fmt=1 header
+*/
+VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    /**
+    * parse the message header.
+    *   3bytes: timestamp delta,    fmt=0,1,2
+    *   3bytes: payload length,     fmt=0,1
+    *   1bytes: message type,       fmt=0,1
+    *   4bytes: stream id,          fmt=0
+    * where:
+    *   fmt=0, 0x0X
+    *   fmt=1, 0x4X
+    *   fmt=2, 0x8X
+    *   fmt=3, 0xCX
+    */
+
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x03,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x04,
+                0x00, 0x00, 0x15, // timestamp
+                0x00, 0x00, 0x90, // length, 144
+                0x08, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x43,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC4, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x43,
+                0x00, 0x00, 0x20, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x10, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_audio());
+        EXPECT_EQ(0x15, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x20, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x40, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+}
+
+/**
+* recv video, audio, video and video, interlaced in chunks.
+* the continue chunks use fmt=1, last video with fmt=1 header,
+* last video changed length
+*/
+VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11Length)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    /**
+    * parse the message header.
+    *   3bytes: timestamp delta,    fmt=0,1,2
+    *   3bytes: payload length,     fmt=0,1
+    *   1bytes: message type,       fmt=0,1
+    *   4bytes: stream id,          fmt=0
+    * where:
+    *   fmt=0, 0x0X
+    *   fmt=1, 0x4X
+    *   fmt=2, 0x8X
+    *   fmt=3, 0xCX
+    */
+
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x03,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x04,
+                0x00, 0x00, 0x15, // timestamp
+                0x00, 0x00, 0x90, // length, 144
+                0x08, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x43,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x20, // length, 288
+                0x09, // message_type
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC4, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x43,
+                0x00, 0x00, 0x20, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x10, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_audio());
+        EXPECT_EQ(0x15, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x20, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x40, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+}
+
+/**
+* recv video, audio, video and video, interlaced in chunks.
+* the continue chunks use fmt=1, last video with fmt=2 header
+*/
+VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    /**
+    * parse the message header.
+    *   3bytes: timestamp delta,    fmt=0,1,2
+    *   3bytes: payload length,     fmt=0,1
+    *   1bytes: message type,       fmt=0,1
+    *   4bytes: stream id,          fmt=0
+    * where:
+    *   fmt=0, 0x0X
+    *   fmt=1, 0x4X
+    *   fmt=2, 0x8X
+    *   fmt=3, 0xCX
+    */
+
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x03,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x04,
+                0x00, 0x00, 0x15, // timestamp
+                0x00, 0x00, 0x90, // length, 144
+                0x08, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x43,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC4, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x83,
+                0x00, 0x00, 0x20, // timestamp
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x10, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_audio());
+        EXPECT_EQ(0x15, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x20, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x40, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+}
+
+/**
+* recv video, audio, video and video, interlaced in chunks.
+* the continue chunks use fmt=1, last video with fmt=2 header,
+* last video changed length
+*/
+VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12Length)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    /**
+    * parse the message header.
+    *   3bytes: timestamp delta,    fmt=0,1,2
+    *   3bytes: payload length,     fmt=0,1
+    *   1bytes: message type,       fmt=0,1
+    *   4bytes: stream id,          fmt=0
+    * where:
+    *   fmt=0, 0x0X
+    *   fmt=1, 0x4X
+    *   fmt=2, 0x8X
+    *   fmt=3, 0xCX
+    */
+
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x03,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x10, // length, 272
+                0x09, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x04,
+                0x00, 0x00, 0x15, // timestamp
+                0x00, 0x00, 0x90, // length, 144
+                0x08, // message_type
+                0x01, 0x00, 0x00, 0x00, // stream_id
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x43,
+                0x00, 0x00, 0x10, // timestamp
+                0x00, 0x01, 0x20, // length, 288
+                0x09, // message_type
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // audio message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC4, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#1
+    if (true) {
+        uint8_t data[] = {
+                // 12bytes header, 1byts chunk header, 11bytes msg heder
+                0x83,
+                0x00, 0x00, 0x20, // timestamp
+                // msg payload start
+                0x02, 0x00, 0x07, 0x63,
+                0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+                0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+                0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+                0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+                0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+                0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+                0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+                0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#2
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+                0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+                0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+                0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+                0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+    // video message, chunk#3
+    if (true) {
+        uint8_t data[] = {
+                0xC3, /*next chunk.*/
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+                0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+        };
+        bio.in_buffer.append((char*)data, sizeof(data));
+    }
+
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x10, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+        EXPECT_EQ(0x110, msg->header.payload_length);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_audio());
+        EXPECT_EQ(0x15, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x20, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+        EXPECT_EQ(0x120, msg->header.payload_length);
+    }
+    if (true) {
+        SrsCommonMessage* msg = NULL;
+        ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+        SrsAutoFree(SrsCommonMessage, msg);
+        EXPECT_TRUE(msg->header.is_video());
+        EXPECT_EQ(0x40, msg->header.timestamp);
+        EXPECT_EQ(0x01, msg->header.stream_id);
+        EXPECT_EQ(0x120, msg->header.payload_length);
+    }
+}
+
+/**
+* recv video, with extended timestamp.
+* small timestamp < 0xffffff
+*/
+VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    /**
+    * parse the message header.
+    *   3bytes: timestamp delta,    fmt=0,1,2
+    *   3bytes: payload length,     fmt=0,1
+    *   1bytes: message type,       fmt=0,1
+    *   4bytes: stream id,          fmt=0
+    * where:
+    *   fmt=0, 0x0X
+    *   fmt=1, 0x4X
+    *   fmt=2, 0x8X
+    *   fmt=3, 0xCX
+    */
+
+    uint8_t data[] = {
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x03,
+            0xff, 0xff, 0xff, // timestamp
+            0x00, 0x00, 0x04, // length
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            0x00, 0x00, 0x00, 0x10, // extended timestamp
+            // msg payload start
+            0x00, 0x00, 0x07, 0x63
+    };
+    bio.in_buffer.append((char*)data, sizeof(data));
+
+    SrsCommonMessage* msg = NULL;
+    ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+    SrsAutoFree(SrsCommonMessage, msg);
+    EXPECT_TRUE(msg->header.is_video());
+    EXPECT_EQ(0x10, msg->header.timestamp);
+}
+
+/**
+* recv video, with extended timestamp.
+* big timestamp > 0xffffff
+*/
+VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage2)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    /**
+    * parse the message header.
+    *   3bytes: timestamp delta,    fmt=0,1,2
+    *   3bytes: payload length,     fmt=0,1
+    *   1bytes: message type,       fmt=0,1
+    *   4bytes: stream id,          fmt=0
+    * where:
+    *   fmt=0, 0x0X
+    *   fmt=1, 0x4X
+    *   fmt=2, 0x8X
+    *   fmt=3, 0xCX
+    */
+
+    uint8_t data[] = {
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x03,
+            0xff, 0xff, 0xff, // timestamp
+            0x00, 0x00, 0x04, // length
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            0x7f, 0x01, 0x02, 0x03, // extended timestamp
+            // msg payload start
+            0x00, 0x00, 0x07, 0x63
+    };
+    bio.in_buffer.append((char*)data, sizeof(data));
+
+    SrsCommonMessage* msg = NULL;
+    ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+    SrsAutoFree(SrsCommonMessage, msg);
+    EXPECT_TRUE(msg->header.is_video());
+    EXPECT_EQ(0x7f010203, msg->header.timestamp);
+}
+
+/**
+* recv video, with extended timestamp.
+* always use 31bits timestamp.
+*/
+// always use 31bits timestamp, for some server may use 32bits extended timestamp.
+VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage3)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    /**
+    * parse the message header.
+    *   3bytes: timestamp delta,    fmt=0,1,2
+    *   3bytes: payload length,     fmt=0,1
+    *   1bytes: message type,       fmt=0,1
+    *   4bytes: stream id,          fmt=0
+    * where:
+    *   fmt=0, 0x0X
+    *   fmt=1, 0x4X
+    *   fmt=2, 0x8X
+    *   fmt=3, 0xCX
+    */
+
+    uint8_t data[] = {
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x03,
+            0xff, 0xff, 0xff, // timestamp
+            0x00, 0x00, 0x04, // length
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            0xff, 0x01, 0x02, 0x03, // extended timestamp
+            // msg payload start
+            0x00, 0x00, 0x07, 0x63
+    };
+    bio.in_buffer.append((char*)data, sizeof(data));
+
+    SrsCommonMessage* msg = NULL;
+    ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+    SrsAutoFree(SrsCommonMessage, msg);
+    EXPECT_TRUE(msg->header.is_video());
+    // always use 31bits timestamp
+    EXPECT_EQ(0x7f010203, msg->header.timestamp);
+}
+
+/**
+* recv video, with extended timestamp, in 2 chunks packet.
+* always send extended timestamp in 0xCX chunk packets.
+*/
+/**
+* RTMP specification and ffmpeg/librtmp is false,
+* but, adobe changed the specification, so flash/FMLE/FMS always true.
+* default to true to support flash/FMLE/FMS.
+*
+* ffmpeg/librtmp may donot send this filed, need to detect the value.
+* @see also: http://blog.csdn.net/win_lin/article/details/13363699
+* compare to the chunk timestamp, which is set by chunk message header
+* type 0,1 or 2.
+*
+* @remark, nginx send the extended-timestamp in sequence-header,
+* and timestamp delta in continue C1 chunks, and so compatible with ffmpeg,
+* that is, there is no continue chunks and extended-timestamp in nginx-rtmp.
+*
+* @remark, srs always send the extended-timestamp, to keep simple,
+* and compatible with adobe products.
+*/
+VOID TEST(ProtocolStackTest, ProtocolRecvVExtTime2Trunk)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    // video message
+    uint8_t data[] = {
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x03,
+            0xff, 0xff, 0xff, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            0x00, 0x01, 0x02, 0x03, // extended timestamp
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            // chunk #2
+            0xC3,
+            0x00, 0x01, 0x02, 0x03, // extended timestamp
+            /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // chunk #2
+            0xC3,
+            0x00, 0x01, 0x02, 0x03, // extended timestamp
+            /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+    };
+    bio.in_buffer.append((char*)data, sizeof(data));
+
+    SrsCommonMessage* msg = NULL;
+    ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+    SrsAutoFree(SrsCommonMessage, msg);
+    EXPECT_TRUE(msg->header.is_video());
+    // 0xCX with extended timestamp.
+    EXPECT_EQ(0x00010203, msg->header.timestamp);
+}
+
+/**
+* recv video, with extended timestamp, in 2 chunks packet.
+* never send extended timestamp in 0xCX chunk packets.
+*/
+// FFMPEG/librtmp, RTMP specification standard protocol.
+VOID TEST(ProtocolStackTest, ProtocolRecvVExtTime2Trunk2)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    // video message
+    uint8_t data[] = {
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x03,
+            0xff, 0xff, 0xff, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            0x00, 0x01, 0x02, 0x03, // extended timestamp
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            // chunk #2
+            0xC3,
+            /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // chunk #2
+            0xC3,
+            /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+    };
+    bio.in_buffer.append((char*)data, sizeof(data));
+
+    SrsCommonMessage* msg = NULL;
+    ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+    SrsAutoFree(SrsCommonMessage, msg);
+    EXPECT_TRUE(msg->header.is_video());
+    // 0xCX without extended timestamp.
+    EXPECT_EQ(0x00010203, msg->header.timestamp);
+}
+
+/**
+* a video message, in 2 chunks packet.
+* use 1B chunk header, min chunk id is 2.
+*/
+VOID TEST(ProtocolStackTest, ProtocolRecvVCid1BMin)
+{
+    MockBufferIO bio;
+    SrsProtocol proto(&bio);
+
+    // video message
+    uint8_t data[] = {
+            // 12bytes header, 1byts chunk header, 11bytes msg heder
+            0x02,
+            0x00, 0x00, 0x00, // timestamp
+            0x00, 0x01, 0x10, // length, 272
+            0x09, // message_type
+            0x00, 0x00, 0x00, 0x00, // stream_id
+            // msg payload start
+            0x02, 0x00, 0x07, 0x63,
+            0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x00, 0x03, 0x61, 0x70, 0x70, 0x02, 0x00, 0x04, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x08, 0x66, 0x6c,
+            0x61, 0x73, 0x68, 0x56, 0x65, 0x72, 0x02, 0x00, 0x0d, 0x57, 0x49, 0x4e, 0x20, 0x31, 0x32, 0x2c,
+            0x30, 0x2c, 0x30, 0x2c, 0x34, 0x31, 0x00, 0x06, 0x73, 0x77, 0x66, 0x55, 0x72, 0x6c, 0x02, 0x00,
+            0x51, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x73, 0x73, 0x72,
+            0x73, 0x2e, 0x6e, 0x65, 0x74, 0x3a, 0x38, 0x30, 0x38, 0x35, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x65,
+            0x72, 0x73, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
+            0x6c, 0x65, 0x61, 0x73, 0x65, 0x2f, 0x73, 0x72, 0x73, 0x5f, 0x70, 0x6c,
+            // chunk #2
+            0xC2, /*next chunk.*/         0x61, 0x79, 0x65, 0x72,
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e,
+            0x32, 0x33, 0x00, 0x05, 0x74, 0x63, 0x55, 0x72, 0x6c, 0x02, 0x00, 0x14, 0x72, 0x74, 0x6d, 0x70,
+            0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x3a, 0x31, 0x39, 0x33, 0x35, 0x2f, 0x6c, 0x69, 0x76, 0x65,
+            0x00, 0x04, 0x66, 0x70, 0x61, 0x64, 0x01, 0x00, 0x00, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+            0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x40, 0x6d, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x0b, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x43, 0x6f, 0x64, 0x65, 0x63, 0x73, 0x00, 0x40, 0xab, 0xee,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x43, 0x6f, 0x64, 0x65,
+            0x63, 0x73, 0x00, 0x40, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            // chunk #2
+            0xC2, /*next chunk.*/
+            0x2e, 0x73, 0x77, 0x66, 0x3f, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x2e
+    };
+    bio.in_buffer.append((char*)data, sizeof(data));
+
+    SrsCommonMessage* msg = NULL;
+    ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
+    SrsAutoFree(SrsCommonMessage, msg);
+    EXPECT_TRUE(msg->header.is_video());
+    // 1B cid(6bits), min is 2
+    EXPECT_EQ(0x02, msg->header.perfer_cid);
+}
+
+VOID TEST(ProtocolKbpsTest, Connections)
+{
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+
+        SrsKbps* kbps = new SrsKbps(clock->set_clock(0));
+        SrsAutoFree(SrsKbps, kbps);
+
+        SrsNetworkDelta* delta = new SrsNetworkDelta();
+        SrsAutoFree(SrsNetworkDelta, delta);
+        delta->set_io(io, io);
+
+        // No data, 0kbps.
+        kbps->add_delta(delta);
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 30s.
+        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_in(30 * 100 * 1000)->set_out(30 * 100 * 1000);
+        kbps->add_delta(delta);
+        kbps->sample();
+
+        EXPECT_EQ(800, kbps->get_recv_kbps());
+        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(800, kbps->get_send_kbps());
+        EXPECT_EQ(800, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 300s.
+        clock->set_clock(330 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_in(330 * 100 * 1000)->set_out(330 * 100 * 1000);
+        kbps->add_delta(delta);
+        kbps->sample();
+
+        EXPECT_EQ(800, kbps->get_recv_kbps());
+        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(800, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(800, kbps->get_send_kbps());
+        EXPECT_EQ(800, kbps->get_send_kbps_30s());
+        EXPECT_EQ(800, kbps->get_send_kbps_5m());
+    }
+
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+
+        SrsKbps* kbps = new SrsKbps(clock->set_clock(0));
+        SrsAutoFree(SrsKbps, kbps);
+
+        SrsNetworkDelta* delta = new SrsNetworkDelta();
+        SrsAutoFree(SrsNetworkDelta, delta);
+        delta->set_io(io, io);
+
+        // No data, 0kbps.
+        kbps->add_delta(delta);
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 30s.
+        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_in(30 * 100 * 1000);
+        kbps->add_delta(delta);
+        kbps->sample();
+
+        EXPECT_EQ(800, kbps->get_recv_kbps());
+        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 300s.
+        clock->set_clock(330 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_in(330 * 100 * 1000);
+        kbps->add_delta(delta);
+        kbps->sample();
+
+        EXPECT_EQ(800, kbps->get_recv_kbps());
+        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(800, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+    }
+
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+
+        SrsKbps* kbps = new SrsKbps(clock->set_clock(0));
+        SrsAutoFree(SrsKbps, kbps);
+
+        SrsNetworkDelta* delta = new SrsNetworkDelta();
+        SrsAutoFree(SrsNetworkDelta, delta);
+        delta->set_io(io, io);
+
+        // No data, 0kbps.
+        kbps->add_delta(delta);
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 30s.
+        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_out(30 * 100 * 1000);
+        kbps->add_delta(delta);
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(800, kbps->get_send_kbps());
+        EXPECT_EQ(800, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 300s.
+        clock->set_clock(330 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_out(330 * 100 * 1000);
+        kbps->add_delta(delta);
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(800, kbps->get_send_kbps());
+        EXPECT_EQ(800, kbps->get_send_kbps_30s());
+        EXPECT_EQ(800, kbps->get_send_kbps_5m());
+    }
+}
+
+VOID TEST(ProtocolKbpsTest, Delta)
+{
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+
+        SrsNetworkDelta* delta = new SrsNetworkDelta();
+        SrsAutoFree(SrsNetworkDelta, delta);
+        delta->set_io(io, io);
+
+        // No data.
+        int64_t in, out;
+        delta->remark(&in, &out);
+        EXPECT_EQ(0, in);
+        EXPECT_EQ(0, out);
+
+        // 800kb.
+        io->set_in(100 * 1000)->set_out(100 * 1000);
+        delta->remark(&in, &out);
+        EXPECT_EQ(100 * 1000, in);
+        EXPECT_EQ(100 * 1000, out);
+
+        // No data.
+        delta->remark(&in, &out);
+        EXPECT_EQ(0, in);
+        EXPECT_EQ(0, out);
+    }
+
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+
+        SrsNetworkDelta* delta = new SrsNetworkDelta();
+        SrsAutoFree(SrsNetworkDelta, delta);
+        delta->set_io(io, io);
+
+        // No data.
+        int64_t in, out;
+        delta->remark(&in, &out);
+        EXPECT_EQ(0, in);
+        EXPECT_EQ(0, out);
+
+        // 800kb.
+        io->set_in(100 * 1000)->set_out(100 * 1000);
+        delta->remark(&in, &out);
+        EXPECT_EQ(100 * 1000, in);
+        EXPECT_EQ(100 * 1000, out);
+
+        // Kbps without io, gather delta.
+        SrsKbps* kbps = new SrsKbps(clock->set_clock(0));
+        SrsAutoFree(SrsKbps, kbps);
+
+        // No data, 0kbps.
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 30s.
+        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
+        kbps->add_delta(30 * in, 30 * out);
+        kbps->sample();
+
+        EXPECT_EQ(800, kbps->get_recv_kbps());
+        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(800, kbps->get_send_kbps());
+        EXPECT_EQ(800, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+    }
+}
+
+VOID TEST(ProtocolKbpsTest, RAWStatistic)
+{
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+
+        SrsNetworkDelta* delta = new SrsNetworkDelta();
+        SrsAutoFree(SrsNetworkDelta, delta);
+        delta->set_io(io, io);
+
+        SrsKbps* kbps = new SrsKbps(clock->set_clock(0));
+        SrsAutoFree(SrsKbps, kbps);
+
+        // No data, 0kbps.
+        kbps->add_delta(delta);
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 30s.
+        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_out(30 * 100 * 1000);
+        kbps->add_delta(delta);
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(800, kbps->get_send_kbps());
+        EXPECT_EQ(800, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+    }
+
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+
+        SrsKbps* kbps = new SrsKbps(clock->set_clock(0));
+        SrsAutoFree(SrsKbps, kbps);
+
+        // No io, no data.
+        EXPECT_EQ(0, kbps->get_recv_bytes());
+        EXPECT_EQ(0, kbps->get_send_bytes());
+
+        // With io, zero data.
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+
+        SrsNetworkDelta* delta = new SrsNetworkDelta();
+        SrsAutoFree(SrsNetworkDelta, delta);
+        delta->set_io(io, io);
+
+        kbps->add_delta(delta);
+        kbps->sample();
+        EXPECT_EQ(0, kbps->get_recv_bytes());
+        EXPECT_EQ(0, kbps->get_send_bytes());
+
+        // With io with data.
+        io->set_in(100 * 1000)->set_out(100 * 1000);
+        kbps->add_delta(delta);
+        kbps->sample();
+        EXPECT_EQ(100 * 1000, kbps->get_recv_bytes());
+        EXPECT_EQ(100 * 1000, kbps->get_send_bytes());
+
+        // No io, cached data.
+        delta->set_io(NULL, NULL);
+        kbps->add_delta(delta);
+        kbps->sample();
+        EXPECT_EQ(100 * 1000, kbps->get_recv_bytes());
+        EXPECT_EQ(100 * 1000, kbps->get_send_bytes());
+
+        // Use the same IO, but as a fresh io.
+        delta->set_io(io, io);
+        kbps->add_delta(delta);
+        kbps->sample();
+        EXPECT_EQ(200 * 1000, kbps->get_recv_bytes());
+        EXPECT_EQ(200 * 1000, kbps->get_send_bytes());
+
+        io->set_in(150 * 1000)->set_out(150 * 1000);
+        kbps->add_delta(delta);
+        kbps->sample();
+        EXPECT_EQ(250 * 1000, kbps->get_recv_bytes());
+        EXPECT_EQ(250 * 1000, kbps->get_send_bytes());
+
+        // No io, cached data.
+        delta->set_io(NULL, NULL);
+        kbps->add_delta(delta);
+        kbps->sample();
+        EXPECT_EQ(250 * 1000, kbps->get_recv_bytes());
+        EXPECT_EQ(250 * 1000, kbps->get_send_bytes());
+    }
+}
+
+VOID TEST(ProtocolKbpsTest, WriteLargeIOVs)
+{
+    srs_error_t err;
+
+    if (true) {
+        iovec iovs[1];
+        iovs[0].iov_base = (char*)"Hello";
+        iovs[0].iov_len = 5;
+
+        MockBufferIO io;
+        ssize_t nn = 0;
+        HELPER_EXPECT_SUCCESS(srs_write_large_iovs(&io, iovs, 1, &nn));
+        EXPECT_EQ(5, nn);
+        EXPECT_EQ(5, io.sbytes);
+    }
+
+    if (true) {
+        iovec iovs[1024];
+        int nn_iovs = (int)(sizeof(iovs)/sizeof(iovec));
+        for (int i = 0; i < nn_iovs; i++) {
+            iovs[i].iov_base = (char*)"Hello";
+            iovs[i].iov_len = 5;
+        }
+
+        MockBufferIO io;
+        ssize_t nn = 0;
+        HELPER_EXPECT_SUCCESS(srs_write_large_iovs(&io, iovs, nn_iovs, &nn));
+        EXPECT_EQ(5 * nn_iovs, nn);
+        EXPECT_EQ(5 * nn_iovs, io.sbytes);
+    }
+
+    if (true) {
+        iovec iovs[1025];
+        int nn_iovs = (int)(sizeof(iovs)/sizeof(iovec));
+        for (int i = 0; i < nn_iovs; i++) {
+            iovs[i].iov_base = (char*)"Hello";
+            iovs[i].iov_len = 5;
+        }
+
+        MockBufferIO io;
+        ssize_t nn = 0;
+        HELPER_EXPECT_SUCCESS(srs_write_large_iovs(&io, iovs, nn_iovs, &nn));
+        EXPECT_EQ(5 * nn_iovs, nn);
+        EXPECT_EQ(5 * nn_iovs, io.sbytes);
+    }
+
+    if (true) {
+        iovec iovs[4096];
+        int nn_iovs = (int)(sizeof(iovs)/sizeof(iovec));
+        for (int i = 0; i < nn_iovs; i++) {
+            iovs[i].iov_base = (char*)"Hello";
+            iovs[i].iov_len = 5;
+        }
+
+        MockBufferIO io;
+        ssize_t nn = 0;
+        HELPER_EXPECT_SUCCESS(srs_write_large_iovs(&io, iovs, nn_iovs, &nn));
+        EXPECT_EQ(5 * nn_iovs, nn);
+        EXPECT_EQ(5 * nn_iovs, io.sbytes);
+    }
+}
+
+VOID TEST(ProtocolKbpsTest, ConnectionsSugar)
+{
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+
+        SrsNetworkKbps* kbps = new SrsNetworkKbps(clock->set_clock(0));
+        SrsAutoFree(SrsNetworkKbps, kbps);
+        kbps->set_io(io, io);
+
+        // No data, 0kbps.
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 30s.
+        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_in(30 * 100 * 1000)->set_out(30 * 100 * 1000);
+        kbps->sample();
+
+        EXPECT_EQ(800, kbps->get_recv_kbps());
+        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(800, kbps->get_send_kbps());
+        EXPECT_EQ(800, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 300s.
+        clock->set_clock(330 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_in(330 * 100 * 1000)->set_out(330 * 100 * 1000);
+        kbps->sample();
+
+        EXPECT_EQ(800, kbps->get_recv_kbps());
+        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(800, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(800, kbps->get_send_kbps());
+        EXPECT_EQ(800, kbps->get_send_kbps_30s());
+        EXPECT_EQ(800, kbps->get_send_kbps_5m());
+    }
+
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+
+        SrsNetworkKbps* kbps = new SrsNetworkKbps(clock->set_clock(0));
+        SrsAutoFree(SrsNetworkKbps, kbps);
+        kbps->set_io(io, io);
+
+        // No data, 0kbps.
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 30s.
+        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_in(30 * 100 * 1000);
+        kbps->sample();
+
+        EXPECT_EQ(800, kbps->get_recv_kbps());
+        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 300s.
+        clock->set_clock(330 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_in(330 * 100 * 1000);
+        kbps->sample();
+
+        EXPECT_EQ(800, kbps->get_recv_kbps());
+        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(800, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+    }
+
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+
+        SrsNetworkKbps* kbps = new SrsNetworkKbps(clock->set_clock(0));
+        SrsAutoFree(SrsNetworkKbps, kbps);
+        kbps->set_io(io, io);
+
+        // No data, 0kbps.
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 30s.
+        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_out(30 * 100 * 1000);
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(800, kbps->get_send_kbps());
+        EXPECT_EQ(800, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 300s.
+        clock->set_clock(330 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_out(330 * 100 * 1000);
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(800, kbps->get_send_kbps());
+        EXPECT_EQ(800, kbps->get_send_kbps_30s());
+        EXPECT_EQ(800, kbps->get_send_kbps_5m());
+    }
+}
+
+VOID TEST(ProtocolKbpsTest, DeltaSugar)
+{
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+
+        // Kbps without io, gather delta.
+        SrsNetworkKbps* kbps = new SrsNetworkKbps(clock->set_clock(0));
+        SrsAutoFree(SrsNetworkKbps, kbps);
+        kbps->set_io(io, io);
+
+        // No data, 0kbps.
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 30s.
+        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_in(30 * 100 * 1000)->set_out(30 * 100 * 1000);
+        kbps->sample();
+
+        EXPECT_EQ(800, kbps->get_recv_kbps());
+        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(800, kbps->get_send_kbps());
+        EXPECT_EQ(800, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+    }
+}
+
+VOID TEST(ProtocolKbpsTest, RAWStatisticSugar)
+{
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+
+        SrsNetworkKbps* kbps = new SrsNetworkKbps(clock->set_clock(0));
+        SrsAutoFree(SrsNetworkKbps, kbps);
+        kbps->set_io(io, io);
+
+        // No data, 0kbps.
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(0, kbps->get_send_kbps());
+        EXPECT_EQ(0, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+
+        // 800kbps in 30s.
+        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
+        io->set_out(30 * 100 * 1000);
+        kbps->sample();
+
+        EXPECT_EQ(0, kbps->get_recv_kbps());
+        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
+        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
+
+        EXPECT_EQ(800, kbps->get_send_kbps());
+        EXPECT_EQ(800, kbps->get_send_kbps_30s());
+        EXPECT_EQ(0, kbps->get_send_kbps_5m());
+    }
+
+    if (true) {
+        MockWallClock* clock = new MockWallClock();
+        SrsAutoFree(MockWallClock, clock);
+
+        SrsNetworkKbps* kbps = new SrsNetworkKbps(clock->set_clock(0));
+        SrsAutoFree(SrsNetworkKbps, kbps);
+
+        // No io, no data.
+        EXPECT_EQ(0, kbps->get_recv_bytes());
+        EXPECT_EQ(0, kbps->get_send_bytes());
+
+        // With io, zero data.
+        MockStatistic* io = new MockStatistic();
+        SrsAutoFree(MockStatistic, io);
+        kbps->set_io(io, io);
+
+        kbps->sample();
+        EXPECT_EQ(0, kbps->get_recv_bytes());
+        EXPECT_EQ(0, kbps->get_send_bytes());
+
+        // With io with data.
+        io->set_in(100 * 1000)->set_out(100 * 1000);
+        kbps->sample();
+        EXPECT_EQ(100 * 1000, kbps->get_recv_bytes());
+        EXPECT_EQ(100 * 1000, kbps->get_send_bytes());
+
+        // No io, cached data.
+        kbps->set_io(NULL, NULL);
+        kbps->sample();
+        EXPECT_EQ(100 * 1000, kbps->get_recv_bytes());
+        EXPECT_EQ(100 * 1000, kbps->get_send_bytes());
+
+        // Use the same IO, but as a fresh io.
+        kbps->set_io(io, io);
+        kbps->sample();
+        EXPECT_EQ(200 * 1000, kbps->get_recv_bytes());
+        EXPECT_EQ(200 * 1000, kbps->get_send_bytes());
+
+        io->set_in(150 * 1000)->set_out(150 * 1000);
+        kbps->sample();
+        EXPECT_EQ(250 * 1000, kbps->get_recv_bytes());
+        EXPECT_EQ(250 * 1000, kbps->get_send_bytes());
+
+        // No io, cached data.
+        kbps->set_io(NULL, NULL);
+        kbps->sample();
+        EXPECT_EQ(250 * 1000, kbps->get_recv_bytes());
+        EXPECT_EQ(250 * 1000, kbps->get_send_bytes());
+    }
+}
+
diff --git a/trunk/src/utest/srs_utest_protocol2.cpp b/trunk/src/utest/srs_utest_protocol2.cpp
deleted file mode 100644
index c1bca05ed..000000000
--- a/trunk/src/utest/srs_utest_protocol2.cpp
+++ /dev/null
@@ -1,707 +0,0 @@
-//
-// Copyright (c) 2013-2022 The SRS Authors
-//
-// SPDX-License-Identifier: MIT or MulanPSL-2.0
-//
-#include <srs_utest_protocol2.hpp>
-
-using namespace std;
-
-#include <srs_kernel_error.hpp>
-#include <srs_core_autofree.hpp>
-#include <srs_protocol_utility.hpp>
-#include <srs_protocol_rtmp_msg_array.hpp>
-#include <srs_protocol_rtmp_stack.hpp>
-#include <srs_kernel_utility.hpp>
-#include <srs_app_st.hpp>
-#include <srs_protocol_amf0.hpp>
-#include <srs_protocol_rtmp_stack.hpp>
-#include <srs_protocol_http_conn.hpp>
-#include <srs_protocol_protobuf.hpp>
-#include <srs_kernel_buffer.hpp>
-
-VOID TEST(ProtocolKbpsTest, Connections)
-{
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-
-        SrsKbps* kbps = new SrsKbps(clock->set_clock(0));
-        SrsAutoFree(SrsKbps, kbps);
-
-        SrsNetworkDelta* delta = new SrsNetworkDelta();
-        SrsAutoFree(SrsNetworkDelta, delta);
-        delta->set_io(io, io);
-
-        // No data, 0kbps.
-        kbps->add_delta(delta);
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 30s.
-        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_in(30 * 100 * 1000)->set_out(30 * 100 * 1000);
-        kbps->add_delta(delta);
-        kbps->sample();
-
-        EXPECT_EQ(800, kbps->get_recv_kbps());
-        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(800, kbps->get_send_kbps());
-        EXPECT_EQ(800, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 300s.
-        clock->set_clock(330 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_in(330 * 100 * 1000)->set_out(330 * 100 * 1000);
-        kbps->add_delta(delta);
-        kbps->sample();
-
-        EXPECT_EQ(800, kbps->get_recv_kbps());
-        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(800, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(800, kbps->get_send_kbps());
-        EXPECT_EQ(800, kbps->get_send_kbps_30s());
-        EXPECT_EQ(800, kbps->get_send_kbps_5m());
-    }
-
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-
-        SrsKbps* kbps = new SrsKbps(clock->set_clock(0));
-        SrsAutoFree(SrsKbps, kbps);
-
-        SrsNetworkDelta* delta = new SrsNetworkDelta();
-        SrsAutoFree(SrsNetworkDelta, delta);
-        delta->set_io(io, io);
-
-        // No data, 0kbps.
-        kbps->add_delta(delta);
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 30s.
-        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_in(30 * 100 * 1000);
-        kbps->add_delta(delta);
-        kbps->sample();
-
-        EXPECT_EQ(800, kbps->get_recv_kbps());
-        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 300s.
-        clock->set_clock(330 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_in(330 * 100 * 1000);
-        kbps->add_delta(delta);
-        kbps->sample();
-
-        EXPECT_EQ(800, kbps->get_recv_kbps());
-        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(800, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-    }
-
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-
-        SrsKbps* kbps = new SrsKbps(clock->set_clock(0));
-        SrsAutoFree(SrsKbps, kbps);
-
-        SrsNetworkDelta* delta = new SrsNetworkDelta();
-        SrsAutoFree(SrsNetworkDelta, delta);
-        delta->set_io(io, io);
-
-        // No data, 0kbps.
-        kbps->add_delta(delta);
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 30s.
-        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_out(30 * 100 * 1000);
-        kbps->add_delta(delta);
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(800, kbps->get_send_kbps());
-        EXPECT_EQ(800, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 300s.
-        clock->set_clock(330 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_out(330 * 100 * 1000);
-        kbps->add_delta(delta);
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(800, kbps->get_send_kbps());
-        EXPECT_EQ(800, kbps->get_send_kbps_30s());
-        EXPECT_EQ(800, kbps->get_send_kbps_5m());
-    }
-}
-
-VOID TEST(ProtocolKbpsTest, Delta)
-{
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-
-        SrsNetworkDelta* delta = new SrsNetworkDelta();
-        SrsAutoFree(SrsNetworkDelta, delta);
-        delta->set_io(io, io);
-
-        // No data.
-        int64_t in, out;
-        delta->remark(&in, &out);
-        EXPECT_EQ(0, in);
-        EXPECT_EQ(0, out);
-
-        // 800kb.
-        io->set_in(100 * 1000)->set_out(100 * 1000);
-        delta->remark(&in, &out);
-        EXPECT_EQ(100 * 1000, in);
-        EXPECT_EQ(100 * 1000, out);
-
-        // No data.
-        delta->remark(&in, &out);
-        EXPECT_EQ(0, in);
-        EXPECT_EQ(0, out);
-    }
-
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-
-        SrsNetworkDelta* delta = new SrsNetworkDelta();
-        SrsAutoFree(SrsNetworkDelta, delta);
-        delta->set_io(io, io);
-
-        // No data.
-        int64_t in, out;
-        delta->remark(&in, &out);
-        EXPECT_EQ(0, in);
-        EXPECT_EQ(0, out);
-
-        // 800kb.
-        io->set_in(100 * 1000)->set_out(100 * 1000);
-        delta->remark(&in, &out);
-        EXPECT_EQ(100 * 1000, in);
-        EXPECT_EQ(100 * 1000, out);
-
-        // Kbps without io, gather delta.
-        SrsKbps* kbps = new SrsKbps(clock->set_clock(0));
-        SrsAutoFree(SrsKbps, kbps);
-
-        // No data, 0kbps.
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 30s.
-        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
-        kbps->add_delta(30 * in, 30 * out);
-        kbps->sample();
-
-        EXPECT_EQ(800, kbps->get_recv_kbps());
-        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(800, kbps->get_send_kbps());
-        EXPECT_EQ(800, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-    }
-}
-
-VOID TEST(ProtocolKbpsTest, RAWStatistic)
-{
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-
-        SrsNetworkDelta* delta = new SrsNetworkDelta();
-        SrsAutoFree(SrsNetworkDelta, delta);
-        delta->set_io(io, io);
-
-        SrsKbps* kbps = new SrsKbps(clock->set_clock(0));
-        SrsAutoFree(SrsKbps, kbps);
-
-        // No data, 0kbps.
-        kbps->add_delta(delta);
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 30s.
-        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_out(30 * 100 * 1000);
-        kbps->add_delta(delta);
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(800, kbps->get_send_kbps());
-        EXPECT_EQ(800, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-    }
-
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-
-        SrsKbps* kbps = new SrsKbps(clock->set_clock(0));
-        SrsAutoFree(SrsKbps, kbps);
-
-        // No io, no data.
-        EXPECT_EQ(0, kbps->get_recv_bytes());
-        EXPECT_EQ(0, kbps->get_send_bytes());
-
-        // With io, zero data.
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-
-        SrsNetworkDelta* delta = new SrsNetworkDelta();
-        SrsAutoFree(SrsNetworkDelta, delta);
-        delta->set_io(io, io);
-
-        kbps->add_delta(delta);
-        kbps->sample();
-        EXPECT_EQ(0, kbps->get_recv_bytes());
-        EXPECT_EQ(0, kbps->get_send_bytes());
-
-        // With io with data.
-        io->set_in(100 * 1000)->set_out(100 * 1000);
-        kbps->add_delta(delta);
-        kbps->sample();
-        EXPECT_EQ(100 * 1000, kbps->get_recv_bytes());
-        EXPECT_EQ(100 * 1000, kbps->get_send_bytes());
-
-        // No io, cached data.
-        delta->set_io(NULL, NULL);
-        kbps->add_delta(delta);
-        kbps->sample();
-        EXPECT_EQ(100 * 1000, kbps->get_recv_bytes());
-        EXPECT_EQ(100 * 1000, kbps->get_send_bytes());
-
-        // Use the same IO, but as a fresh io.
-        delta->set_io(io, io);
-        kbps->add_delta(delta);
-        kbps->sample();
-        EXPECT_EQ(200 * 1000, kbps->get_recv_bytes());
-        EXPECT_EQ(200 * 1000, kbps->get_send_bytes());
-
-        io->set_in(150 * 1000)->set_out(150 * 1000);
-        kbps->add_delta(delta);
-        kbps->sample();
-        EXPECT_EQ(250 * 1000, kbps->get_recv_bytes());
-        EXPECT_EQ(250 * 1000, kbps->get_send_bytes());
-
-        // No io, cached data.
-        delta->set_io(NULL, NULL);
-        kbps->add_delta(delta);
-        kbps->sample();
-        EXPECT_EQ(250 * 1000, kbps->get_recv_bytes());
-        EXPECT_EQ(250 * 1000, kbps->get_send_bytes());
-    }
-}
-
-VOID TEST(ProtocolKbpsTest, WriteLargeIOVs)
-{
-    srs_error_t err;
-
-    if (true) {
-        iovec iovs[1];
-        iovs[0].iov_base = (char*)"Hello";
-        iovs[0].iov_len = 5;
-
-        MockBufferIO io;
-        ssize_t nn = 0;
-        HELPER_EXPECT_SUCCESS(srs_write_large_iovs(&io, iovs, 1, &nn));
-        EXPECT_EQ(5, nn);
-        EXPECT_EQ(5, io.sbytes);
-    }
-
-    if (true) {
-        iovec iovs[1024];
-        int nn_iovs = (int)(sizeof(iovs)/sizeof(iovec));
-        for (int i = 0; i < nn_iovs; i++) {
-            iovs[i].iov_base = (char*)"Hello";
-            iovs[i].iov_len = 5;
-        }
-
-        MockBufferIO io;
-        ssize_t nn = 0;
-        HELPER_EXPECT_SUCCESS(srs_write_large_iovs(&io, iovs, nn_iovs, &nn));
-        EXPECT_EQ(5 * nn_iovs, nn);
-        EXPECT_EQ(5 * nn_iovs, io.sbytes);
-    }
-
-    if (true) {
-        iovec iovs[1025];
-        int nn_iovs = (int)(sizeof(iovs)/sizeof(iovec));
-        for (int i = 0; i < nn_iovs; i++) {
-            iovs[i].iov_base = (char*)"Hello";
-            iovs[i].iov_len = 5;
-        }
-
-        MockBufferIO io;
-        ssize_t nn = 0;
-        HELPER_EXPECT_SUCCESS(srs_write_large_iovs(&io, iovs, nn_iovs, &nn));
-        EXPECT_EQ(5 * nn_iovs, nn);
-        EXPECT_EQ(5 * nn_iovs, io.sbytes);
-    }
-
-    if (true) {
-        iovec iovs[4096];
-        int nn_iovs = (int)(sizeof(iovs)/sizeof(iovec));
-        for (int i = 0; i < nn_iovs; i++) {
-            iovs[i].iov_base = (char*)"Hello";
-            iovs[i].iov_len = 5;
-        }
-
-        MockBufferIO io;
-        ssize_t nn = 0;
-        HELPER_EXPECT_SUCCESS(srs_write_large_iovs(&io, iovs, nn_iovs, &nn));
-        EXPECT_EQ(5 * nn_iovs, nn);
-        EXPECT_EQ(5 * nn_iovs, io.sbytes);
-    }
-}
-
-VOID TEST(ProtocolKbpsTest, ConnectionsSugar)
-{
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-
-        SrsNetworkKbps* kbps = new SrsNetworkKbps(clock->set_clock(0));
-        SrsAutoFree(SrsNetworkKbps, kbps);
-        kbps->set_io(io, io);
-
-        // No data, 0kbps.
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 30s.
-        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_in(30 * 100 * 1000)->set_out(30 * 100 * 1000);
-        kbps->sample();
-
-        EXPECT_EQ(800, kbps->get_recv_kbps());
-        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(800, kbps->get_send_kbps());
-        EXPECT_EQ(800, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 300s.
-        clock->set_clock(330 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_in(330 * 100 * 1000)->set_out(330 * 100 * 1000);
-        kbps->sample();
-
-        EXPECT_EQ(800, kbps->get_recv_kbps());
-        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(800, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(800, kbps->get_send_kbps());
-        EXPECT_EQ(800, kbps->get_send_kbps_30s());
-        EXPECT_EQ(800, kbps->get_send_kbps_5m());
-    }
-
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-
-        SrsNetworkKbps* kbps = new SrsNetworkKbps(clock->set_clock(0));
-        SrsAutoFree(SrsNetworkKbps, kbps);
-        kbps->set_io(io, io);
-
-        // No data, 0kbps.
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 30s.
-        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_in(30 * 100 * 1000);
-        kbps->sample();
-
-        EXPECT_EQ(800, kbps->get_recv_kbps());
-        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 300s.
-        clock->set_clock(330 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_in(330 * 100 * 1000);
-        kbps->sample();
-
-        EXPECT_EQ(800, kbps->get_recv_kbps());
-        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(800, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-    }
-
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-
-        SrsNetworkKbps* kbps = new SrsNetworkKbps(clock->set_clock(0));
-        SrsAutoFree(SrsNetworkKbps, kbps);
-        kbps->set_io(io, io);
-
-        // No data, 0kbps.
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 30s.
-        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_out(30 * 100 * 1000);
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(800, kbps->get_send_kbps());
-        EXPECT_EQ(800, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 300s.
-        clock->set_clock(330 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_out(330 * 100 * 1000);
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(800, kbps->get_send_kbps());
-        EXPECT_EQ(800, kbps->get_send_kbps_30s());
-        EXPECT_EQ(800, kbps->get_send_kbps_5m());
-    }
-}
-
-VOID TEST(ProtocolKbpsTest, DeltaSugar)
-{
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-
-        // Kbps without io, gather delta.
-        SrsNetworkKbps* kbps = new SrsNetworkKbps(clock->set_clock(0));
-        SrsAutoFree(SrsNetworkKbps, kbps);
-        kbps->set_io(io, io);
-
-        // No data, 0kbps.
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 30s.
-        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_in(30 * 100 * 1000)->set_out(30 * 100 * 1000);
-        kbps->sample();
-
-        EXPECT_EQ(800, kbps->get_recv_kbps());
-        EXPECT_EQ(800, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(800, kbps->get_send_kbps());
-        EXPECT_EQ(800, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-    }
-}
-
-VOID TEST(ProtocolKbpsTest, RAWStatisticSugar)
-{
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-
-        SrsNetworkKbps* kbps = new SrsNetworkKbps(clock->set_clock(0));
-        SrsAutoFree(SrsNetworkKbps, kbps);
-        kbps->set_io(io, io);
-
-        // No data, 0kbps.
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(0, kbps->get_send_kbps());
-        EXPECT_EQ(0, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-
-        // 800kbps in 30s.
-        clock->set_clock(30 * 1000 * SRS_UTIME_MILLISECONDS);
-        io->set_out(30 * 100 * 1000);
-        kbps->sample();
-
-        EXPECT_EQ(0, kbps->get_recv_kbps());
-        EXPECT_EQ(0, kbps->get_recv_kbps_30s());
-        EXPECT_EQ(0, kbps->get_recv_kbps_5m());
-
-        EXPECT_EQ(800, kbps->get_send_kbps());
-        EXPECT_EQ(800, kbps->get_send_kbps_30s());
-        EXPECT_EQ(0, kbps->get_send_kbps_5m());
-    }
-
-    if (true) {
-        MockWallClock* clock = new MockWallClock();
-        SrsAutoFree(MockWallClock, clock);
-
-        SrsNetworkKbps* kbps = new SrsNetworkKbps(clock->set_clock(0));
-        SrsAutoFree(SrsNetworkKbps, kbps);
-
-        // No io, no data.
-        EXPECT_EQ(0, kbps->get_recv_bytes());
-        EXPECT_EQ(0, kbps->get_send_bytes());
-
-        // With io, zero data.
-        MockStatistic* io = new MockStatistic();
-        SrsAutoFree(MockStatistic, io);
-        kbps->set_io(io, io);
-
-        kbps->sample();
-        EXPECT_EQ(0, kbps->get_recv_bytes());
-        EXPECT_EQ(0, kbps->get_send_bytes());
-
-        // With io with data.
-        io->set_in(100 * 1000)->set_out(100 * 1000);
-        kbps->sample();
-        EXPECT_EQ(100 * 1000, kbps->get_recv_bytes());
-        EXPECT_EQ(100 * 1000, kbps->get_send_bytes());
-
-        // No io, cached data.
-        kbps->set_io(NULL, NULL);
-        kbps->sample();
-        EXPECT_EQ(100 * 1000, kbps->get_recv_bytes());
-        EXPECT_EQ(100 * 1000, kbps->get_send_bytes());
-
-        // Use the same IO, but as a fresh io.
-        kbps->set_io(io, io);
-        kbps->sample();
-        EXPECT_EQ(200 * 1000, kbps->get_recv_bytes());
-        EXPECT_EQ(200 * 1000, kbps->get_send_bytes());
-
-        io->set_in(150 * 1000)->set_out(150 * 1000);
-        kbps->sample();
-        EXPECT_EQ(250 * 1000, kbps->get_recv_bytes());
-        EXPECT_EQ(250 * 1000, kbps->get_send_bytes());
-
-        // No io, cached data.
-        kbps->set_io(NULL, NULL);
-        kbps->sample();
-        EXPECT_EQ(250 * 1000, kbps->get_recv_bytes());
-        EXPECT_EQ(250 * 1000, kbps->get_send_bytes());
-    }
-}
-
diff --git a/trunk/src/utest/srs_utest_protocol2.hpp b/trunk/src/utest/srs_utest_protocol2.hpp
deleted file mode 100644
index 29289306e..000000000
--- a/trunk/src/utest/srs_utest_protocol2.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-//
-// Copyright (c) 2013-2022 The SRS Authors
-//
-// SPDX-License-Identifier: MIT or MulanPSL-2.0
-//
-
-#ifndef SRS_UTEST_PROTOCOL2_HPP
-#define SRS_UTEST_PROTOCOL2_HPP
-
-/*
-#include <srs_utest_protocol2.hpp>
-*/
-#include <srs_utest_protocol.hpp>
-
-#endif
-