Refactor SRT, using reverse dependency, SRT depends on APP.

README.md

@@ -990,13 +990,13 @@ SRS always use the simplest architecture to solve complex domain problems.
 ## Modularity Architecture
 
 ```
-+------------------------------------------------------+
-|    SRS server    |   Programs in Main or Research    |
-+------------------------------------------------------+
++----------------+-------------------------------------+
+| SRS/SRT server |    Programs in Main or Research     |
++----------------+--+------------+---------------------+
 |  App(For SRS)     | Modules(1) |  research/librtmp   |
-+------------------------------------------------------+
-|    Service(C/S apps over ST)  | Libs(Export librtmp) |
-+------------------------------------------------------+
++-------------------+------------+---------------------+
+|    Service(C/S apps over ST)   |     srs-librtmp     |
++--------------------------------+---------------------+
 |   Protocol Stack(RTMP/HTTP/RTSP/JSON/AMF/Format)     |
 +------------------------------------------------------+
 |      Kernel(File, Codec, Stream, LB services)        |

trunk/configure

@@ -245,9 +245,6 @@ if [ $SRS_EXPORT_LIBRTMP_PROJECT = NO ]; then
     MODULE_ID="APP" 
     MODULE_DEPENDS=("CORE" "KERNEL" "PROTOCOL" "SERVICE")
     ModuleLibIncs=(${LibSTRoot} ${SRS_OBJS_DIR} ${LibSSLRoot})
-    if [[ $SRS_SRT == YES ]]; then
-        ModuleLibIncs+=("${LibSRTRoot[*]}")
-    fi
     MODULE_FILES=("srs_app_server" "srs_app_conn" "srs_app_rtmp_conn" "srs_app_source" 
             "srs_app_refer" "srs_app_hls" "srs_app_forward" "srs_app_encoder" "srs_app_http_stream"
             "srs_app_thread" "srs_app_bandwidth" "srs_app_st" "srs_app_log" "srs_app_config" 

trunk/src/app/srs_app_hybrid.cpp

@@ -25,18 +25,30 @@
 
 #include <srs_app_server.hpp>
 #include <srs_app_config.hpp>
+#include <srs_kernel_error.hpp>
+#include <srs_service_st.hpp>
 
-SrsHybridServer::SrsHybridServer()
+using namespace std;
+
+ISrsHybridServer::ISrsHybridServer()
+{
+}
+
+ISrsHybridServer::~ISrsHybridServer()
+{
+}
+
+SrsServerAdapter::SrsServerAdapter()
 {
     srs = new SrsServer();
 }
 
-SrsHybridServer::~SrsHybridServer()
+SrsServerAdapter::~SrsServerAdapter()
 {
     srs_freep(srs);
 }
 
-srs_error_t SrsHybridServer::initialize()
+srs_error_t SrsServerAdapter::initialize()
 {
     srs_error_t err = srs_success;
 
@@ -49,30 +61,10 @@ srs_error_t SrsHybridServer::initialize()
         return srs_error_wrap(err, "initialize st");
     }
 
-#ifdef SRS_AUTO_SRT
-    if(_srs_config->get_srt_enabled()) {
-        srs_trace("srt server is enabled...");
-        unsigned short srt_port = _srs_config->get_srt_listen_port();
-        srs_trace("srt server listen port:%d", srt_port);
-        err = srt2rtmp::get_instance()->init();
-        if (err != srs_success) {
-            srs_error_wrap(err, "srt start srt2rtmp error");
-            return err;
-        }
-
-        srt_ptr = std::make_shared<srt_server>(srt_port);
-        if (!srt_ptr) {
-            srs_error_wrap(err, "srt listen %d", srt_port);
-        }
-    } else {
-        srs_trace("srt server is disabled...");
-    }
-#endif
-
     return err;
 }
 
-srs_error_t SrsHybridServer::run()
+srs_error_t SrsServerAdapter::run()
 {
     srs_error_t err = srs_success;
 
@@ -100,12 +92,6 @@ srs_error_t SrsHybridServer::run()
         return srs_error_wrap(err, "ingest");
     }
 
-#ifdef SRS_AUTO_SRT
-    if(_srs_config->get_srt_enabled()) {
-        srt_ptr->start();
-    }
-#endif
-
     if ((err = srs->cycle()) != srs_success) {
         return srs_error_wrap(err, "main cycle");
     }
@@ -113,3 +99,75 @@ srs_error_t SrsHybridServer::run()
     return err;
 }
 
+SrsHybridServer::SrsHybridServer()
+{
+}
+
+SrsHybridServer::~SrsHybridServer()
+{
+    vector<ISrsHybridServer*>::iterator it;
+    for (it = servers.begin(); it != servers.end(); ++it) {
+        ISrsHybridServer* server = *it;
+        srs_freep(server);
+    }
+    servers.clear();
+}
+
+void SrsHybridServer::register_server(ISrsHybridServer* svr)
+{
+    servers.push_back(svr);
+}
+
+srs_error_t SrsHybridServer::initialize()
+{
+    srs_error_t err = srs_success;
+
+    // init st
+    if ((err = srs_st_init()) != srs_success) {
+        return srs_error_wrap(err, "initialize st failed");
+    }
+
+    vector<ISrsHybridServer*>::iterator it;
+    for (it = servers.begin(); it != servers.end(); ++it) {
+        ISrsHybridServer* server = *it;
+
+        if ((err = server->initialize()) != srs_success) {
+            return srs_error_wrap(err, "init server");
+        }
+    }
+
+    return err;
+}
+
+srs_error_t SrsHybridServer::run()
+{
+    srs_error_t err = srs_success;
+
+    // Run master server in this main thread.
+    SrsServerAdapter* master_server = NULL;
+
+    vector<ISrsHybridServer*>::iterator it;
+    for (it = servers.begin(); it != servers.end(); ++it) {
+        ISrsHybridServer* server = *it;
+
+        if (!master_server) {
+            master_server = dynamic_cast<SrsServerAdapter*>(server);
+            if (master_server) {
+                continue;
+            }
+        }
+
+        if ((err = server->run()) != srs_success) {
+            return srs_error_wrap(err, "run server");
+        }
+    }
+
+    if (master_server) {
+        return master_server->run();
+    }
+
+    return err;
+}
+
+SrsHybridServer* _srs_hybrid = new SrsHybridServer();
+

trunk/src/app/srs_app_hybrid.hpp

@@ -26,26 +26,46 @@
 
 #include <srs_core.hpp>
 
-#ifdef SRS_AUTO_SRT
-#include <srt_server.hpp>
-#include <srt_to_rtmp.hpp>
-#endif
+#include <vector>
 
 class SrsServer;
 
-class SrsHybridServer
+class ISrsHybridServer
+{
+public:
+    ISrsHybridServer();
+    virtual ~ISrsHybridServer();
+public:
+    virtual srs_error_t initialize() = 0;
+    virtual srs_error_t run() = 0;
+};
+
+class SrsServerAdapter : public ISrsHybridServer
 {
 private:
     SrsServer* srs;
-#ifdef SRS_AUTO_SRT
-    SRT_SERVER_PTR srt_ptr;
-#endif
 public:
-    SrsHybridServer();
-    virtual ~SrsHybridServer();
+    SrsServerAdapter();
+    virtual ~SrsServerAdapter();
 public:
     virtual srs_error_t initialize();
     virtual srs_error_t run();
 };
 
+class SrsHybridServer
+{
+private:
+    std::vector<ISrsHybridServer*> servers;
+public:
+    SrsHybridServer();
+    virtual ~SrsHybridServer();
+public:
+    virtual void register_server(ISrsHybridServer* svr);
+public:
+    virtual srs_error_t initialize();
+    virtual srs_error_t run();
+};
+
+extern SrsHybridServer* _srs_hybrid;
+
 #endif

trunk/src/app/srs_app_server.cpp

@@ -565,11 +565,6 @@ srs_error_t SrsServer::initialize_st()
 {
     srs_error_t err = srs_success;
     
-    // init st
-    if ((err = srs_st_init()) != srs_success) {
-        return srs_error_wrap(err, "initialize st failed");
-    }
-    
     // @remark, st alloc segment use mmap, which only support 32757 threads,
     // if need to support more, for instance, 100k threads, define the macro MALLOC_STACK.
     // TODO: FIXME: maybe can use "sysctl vm.max_map_count" to refine.

trunk/src/main/srs_main_server.cpp

@@ -50,6 +50,10 @@ using namespace std;
 #include <srs_core_autofree.hpp>
 #include <srs_app_hybrid.hpp>
 
+#ifdef SRS_AUTO_SRT
+#include <srt_server.hpp>
+#endif
+
 // pre-declare
 srs_error_t run_directly_or_daemon();
 srs_error_t run_hybrid_server();
@@ -411,14 +415,16 @@ srs_error_t run_hybrid_server()
 {
     srs_error_t err = srs_success;
 
-    SrsHybridServer* svr = new SrsHybridServer();
-    SrsAutoFree(SrsHybridServer, svr);
+    _srs_hybrid->register_server(new SrsServerAdapter());
+#ifdef SRS_AUTO_SRT
+    _srs_hybrid->register_server(new SrtServerAdapter());
+#endif
 
-    if ((err = svr->initialize()) != srs_success) {
+    if ((err = _srs_hybrid->initialize()) != srs_success) {
         return srs_error_wrap(err, "hybrid initialize");
     }
 
-    if ((err = svr->run()) != srs_success) {
+    if ((err = _srs_hybrid->run()) != srs_success) {
         return srs_error_wrap(err, "hybrid run");
     }
 

trunk/src/srt/srt_server.cpp

@@ -199,3 +199,47 @@ void srt_server::on_work()
         }
     }
 }
+
+SrtServerAdapter::SrtServerAdapter()
+{
+}
+
+SrtServerAdapter::~SrtServerAdapter()
+{
+}
+
+srs_error_t SrtServerAdapter::initialize()
+{
+    srs_error_t err = srs_success;
+
+    if(_srs_config->get_srt_enabled()) {
+        srs_trace("srt server is enabled...");
+        unsigned short srt_port = _srs_config->get_srt_listen_port();
+        srs_trace("srt server listen port:%d", srt_port);
+        err = srt2rtmp::get_instance()->init();
+        if (err != srs_success) {
+            srs_error_wrap(err, "srt start srt2rtmp error");
+            return err;
+        }
+
+        srt_ptr = std::make_shared<srt_server>(srt_port);
+        if (!srt_ptr) {
+            srs_error_wrap(err, "srt listen %d", srt_port);
+        }
+    } else {
+        srs_trace("srt server is disabled...");
+    }
+
+    return err;
+}
+
+srs_error_t SrtServerAdapter::run()
+{
+    srs_error_t err = srs_success;
+
+    if(_srs_config->get_srt_enabled()) {
+        srt_ptr->start();
+    }
+
+    return err;
+}

trunk/src/srt/srt_server.hpp

@@ -1,10 +1,13 @@
 #ifndef SRT_SERVER_H
 #define SRT_SERVER_H
+
 #include <srt/srt.h>
 
 #include <thread>
 #include <memory>
 
+#include <srs_app_hybrid.hpp>
+
 class srt_handle;
 
 class srt_server {
@@ -34,4 +37,16 @@ private:
 
 typedef std::shared_ptr<srt_server> SRT_SERVER_PTR;
 
+class SrtServerAdapter : public ISrsHybridServer
+{
+private:
+    SRT_SERVER_PTR srt_ptr;
+public:
+    SrtServerAdapter();
+    virtual ~SrtServerAdapter();
+public:
+    virtual srs_error_t initialize();
+    virtual srs_error_t run();
+};
+
 #endif//SRT_SERVER_H