diff --git a/trunk/src/kernel/srs_kernel_utility.cpp b/trunk/src/kernel/srs_kernel_utility.cpp
index e461445a0..2cd9d88f1 100644
--- a/trunk/src/kernel/srs_kernel_utility.cpp
+++ b/trunk/src/kernel/srs_kernel_utility.cpp
@@ -481,7 +481,8 @@ int srs_string_count(string str, string flag)
 }
 
 
-vector<string> srs_string_split(string s, string seperator) {
+vector<string> srs_string_split(string s, string seperator)
+{
     vector<string> result;
     if(seperator.empty()){
         result.push_back(s);
@@ -500,33 +501,33 @@ vector<string> srs_string_split(string s, string seperator) {
     return result;
 }
 
-string srs_string_min_match(string str, vector<string> flags)
+string srs_string_min_match(string str, vector<string> seperators)
 {
     string match;
     
-    if (flags.empty()) {
+    if (seperators.empty()) {
         return str;
     }
     
     size_t min_pos = string::npos;
-    for (vector<string>::iterator it = flags.begin(); it != flags.end(); ++it) {
-        string flag = *it;
+    for (vector<string>::iterator it = seperators.begin(); it != seperators.end(); ++it) {
+        string seperator = *it;
         
-        size_t pos = str.find(flag);
+        size_t pos = str.find(seperator);
         if (pos == string::npos) {
             continue;
         }
         
         if (min_pos == string::npos || pos < min_pos) {
             min_pos = pos;
-            match = flag;
+            match = seperator;
         }
     }
     
     return match;
 }
 
-vector<string> srs_string_split(string str, vector<string> flags)
+vector<string> srs_string_split(string str, vector<string> seperators)
 {
     vector<string> arr;
     
@@ -534,19 +535,17 @@ vector<string> srs_string_split(string str, vector<string> flags)
     string s = str;
     
     while (true) {
-        string flag = srs_string_min_match(s, flags);
-        if (flag.empty()) {
+        string seperator = srs_string_min_match(s, seperators);
+        if (seperator.empty()) {
             break;
         }
         
-        if ((pos = s.find(flag)) == string::npos) {
+        if ((pos = s.find(seperator)) == string::npos) {
             break;
         }
-        
-        if (pos != 0) {
-            arr.push_back(s.substr(0, pos));
-        }
-        s = s.substr(pos + flag.length());
+
+        arr.push_back(s.substr(0, pos));
+        s = s.substr(pos + seperator.length());
     }
     
     if (!s.empty()) {
diff --git a/trunk/src/kernel/srs_kernel_utility.hpp b/trunk/src/kernel/srs_kernel_utility.hpp
index 1f0f56491..5a388d129 100644
--- a/trunk/src/kernel/srs_kernel_utility.hpp
+++ b/trunk/src/kernel/srs_kernel_utility.hpp
@@ -102,9 +102,9 @@ extern bool srs_string_contains(std::string str, std::string flag0, std::string
 extern int srs_string_count(std::string str, std::string flag);
 // Find the min match in str for flags.
 extern std::string srs_string_min_match(std::string str, std::vector<std::string> flags);
-// Split the string by flag to array.
+// Split the string by seperator to array.
 extern std::vector<std::string> srs_string_split(std::string s, std::string seperator);
-extern std::vector<std::string> srs_string_split(std::string str, std::vector<std::string> flags);
+extern std::vector<std::string> srs_string_split(std::string s, std::vector<std::string> seperators);
 
 // Compare the memory in bytes.
 // @return true if completely equal; otherwise, false.
diff --git a/trunk/src/utest/srs_utest_kernel.cpp b/trunk/src/utest/srs_utest_kernel.cpp
index 4ca8b0c61..bac1199c0 100644
--- a/trunk/src/utest/srs_utest_kernel.cpp
+++ b/trunk/src/utest/srs_utest_kernel.cpp
@@ -2626,7 +2626,70 @@ VOID TEST(KernelUtility, StringUtils)
         flags.push_back("x");
         EXPECT_TRUE("" == srs_string_min_match("srs", flags));
     }
-    
+}
+
+VOID TEST(KernelUtility, StringSplitUtils)
+{
+    if (true) {
+        vector<string> ss = srs_string_split("ossrs", "r");
+        EXPECT_EQ(2, ss.size());
+        EXPECT_STREQ("oss", ss.at(0).c_str());
+        EXPECT_STREQ("s", ss.at(1).c_str());
+    }
+
+    if (true) {
+        vector<string> ss = srs_string_split("ossrs", "");
+        EXPECT_EQ(1, ss.size());
+        EXPECT_STREQ("ossrs", ss.at(0).c_str());
+    }
+
+    if (true) {
+        vector<string> ss = srs_string_split("ossrs", "live");
+        EXPECT_EQ(1, ss.size());
+        EXPECT_STREQ("ossrs", ss.at(0).c_str());
+    }
+
+    if (true) {
+        vector<string> ss = srs_string_split("srs,live,rtc", ",");
+        EXPECT_EQ(3, ss.size());
+        EXPECT_STREQ("srs", ss.at(0).c_str());
+        EXPECT_STREQ("live", ss.at(1).c_str());
+        EXPECT_STREQ("rtc", ss.at(2).c_str());
+    }
+
+    if (true) {
+        vector<string> ss = srs_string_split("srs,,rtc", ",");
+        EXPECT_EQ(3, ss.size());
+        EXPECT_STREQ("srs", ss.at(0).c_str());
+        EXPECT_STREQ("", ss.at(1).c_str());
+        EXPECT_STREQ("rtc", ss.at(2).c_str());
+    }
+
+    if (true) {
+        vector<string> ss = srs_string_split("srs,,,rtc", ",");
+        EXPECT_EQ(4, ss.size());
+        EXPECT_STREQ("srs", ss.at(0).c_str());
+        EXPECT_STREQ("", ss.at(1).c_str());
+        EXPECT_STREQ("", ss.at(2).c_str());
+        EXPECT_STREQ("rtc", ss.at(3).c_str());
+    }
+
+    if (true) {
+        vector<string> ss = srs_string_split("srs,live,", ",");
+        EXPECT_EQ(3, ss.size());
+        EXPECT_STREQ("srs", ss.at(0).c_str());
+        EXPECT_STREQ("live", ss.at(1).c_str());
+        EXPECT_STREQ("", ss.at(2).c_str());
+    }
+
+    if (true) {
+        vector<string> ss = srs_string_split(",live,rtc", ",");
+        EXPECT_EQ(3, ss.size());
+        EXPECT_STREQ("", ss.at(0).c_str());
+        EXPECT_STREQ("live", ss.at(1).c_str());
+        EXPECT_STREQ("rtc", ss.at(2).c_str());
+    }
+
     if (true) {
         EXPECT_TRUE("srs" == srs_string_split("srs", "").at(0));
         EXPECT_TRUE("s" == srs_string_split("srs", "r").at(0));
@@ -2634,6 +2697,50 @@ VOID TEST(KernelUtility, StringUtils)
     }
 }
 
+VOID TEST(KernelUtility, StringSplitUtils2)
+{
+    if (true) {
+        vector<string> flags;
+        flags.push_back("e");
+        flags.push_back("wo");
+        vector<string> ss = srs_string_split("hello, world", flags);
+        EXPECT_EQ(3, (int)ss.size());
+        EXPECT_STREQ("h", ss.at(0).c_str());
+        EXPECT_STREQ("llo, ", ss.at(1).c_str());
+        EXPECT_STREQ("rld", ss.at(2).c_str());
+    }
+
+    if (true) {
+        vector<string> flags;
+        flags.push_back("");
+        flags.push_back("");
+        vector<string> ss = srs_string_split("hello, world", flags);
+        EXPECT_EQ(1, (int)ss.size());
+        EXPECT_STREQ("hello, world", ss.at(0).c_str());
+    }
+
+    if (true) {
+        vector<string> flags;
+        flags.push_back(",");
+        flags.push_back(" ");
+        vector<string> ss = srs_string_split("hello, world", flags);
+        EXPECT_EQ(3, (int)ss.size());
+        EXPECT_STREQ("hello", ss.at(0).c_str());
+        EXPECT_STREQ("", ss.at(1).c_str());
+        EXPECT_STREQ("world", ss.at(2).c_str());
+    }
+
+    if (true) {
+        vector<string> flags;
+        flags.push_back(",");
+        vector<string> ss = srs_string_split("hello,,world", flags);
+        EXPECT_EQ(3, (int)ss.size());
+        EXPECT_STREQ("hello", ss.at(0).c_str());
+        EXPECT_STREQ("", ss.at(1).c_str());
+        EXPECT_STREQ("world", ss.at(2).c_str());
+    }
+}
+
 VOID TEST(KernelUtility, BytesUtils)
 {
     if (true) {
@@ -4483,17 +4590,6 @@ VOID TEST(KernelUtilityTest, CoverTimeUtilityAll)
         EXPECT_STREQ("off", srs_bool2switch(false).c_str());
     }
     
-    if (true) {
-        vector<string> flags;
-        flags.push_back("e");
-        flags.push_back("wo");
-        vector<string> ss = srs_string_split("hello, world", flags);
-        EXPECT_EQ(3, (int)ss.size());
-        EXPECT_STREQ("h", ss.at(0).c_str());
-        EXPECT_STREQ("llo, ", ss.at(1).c_str());
-        EXPECT_STREQ("rld", ss.at(2).c_str());
-    }
-    
     if (true) {
         EXPECT_EQ('H', av_toupper('h'));
     }