SRS(simple-rtmp-server)流媒体服务器源码分析--启动

已于 2022-06-01 17:00:08 修改
阅读量1.7w 收藏 67
点赞数 30
分类专栏： SRS 文章标签： SRS 流媒体服务器 代码分析
于 2017-06-28 14:18:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/manageruser/article/details/73840130
版权

SRS(simple-rtmp-server)流媒体服务器源码分析--系统启动

一、前言

       小卒最近看SRS源码，随手写下博客，其一为了整理思路，其二也是为日后翻看方便。如果不足之处，请指教！

首先总结一下SRS源码的优点：

       1、轻量级，代码结构清楚，目前SRS3.0代码8万行左右，但几乎满足直播业务的所有要求。

       2、SRS采用State Threads，支持高并发量，高性能。

       3、SRS支持rtmp和hls，满足PC和移动直播要求。

       4、SRS支持集群部署。小集群Forward，大集群edge。

代码分析可分为两个阶段：
       一：分析代码框架，理清楚组织流程
       二：分析代码细节，熟悉SRS工作原理

二、代码分析

       相关SRS源码其他总结：

           SRS(simple-rtmp-server)流媒体服务器源码分析--系统启动
           SRS(simple-rtmp-server)流媒体服务器源码分析--RTMP消息play

           SRS(simple-rtmp-server)流媒体服务器源码分析--RTMP信息Publish

           SRS(simple-rtmp-server)流媒体服务器源码分析--HLS切片

现阶段，我主要以代码框架梳理为主。Srs源码框架如下图：

       
         系统在启动时，初始化相关类，监听相关端口，若来一个访问请求，则为该链接创建一个线程，专门处理与该链接的操作。
         main函数在srs_main_server.cpp这个文件中。在main函数中，启动参数在这里不做过多介绍。直接从run(）-> run_master()看起。 
int run_master()
{
    int ret = ERROR_SUCCESS;
    
    if ((ret = _srs_server->initialize_st()) != ERROR_SUCCESS) {
        return ret;
    }
    
    if ((ret = _srs_server->initialize_signal()) != ERROR_SUCCESS) {
        return ret;
    }
    //将pid进程号写进文件
    if ((ret = _srs_server->acquire_pid_file()) != ERROR_SUCCESS) {
        return ret;
    }
    //客户端监听
    if ((ret = _srs_server->listen()) != ERROR_SUCCESS) {
        return ret;
    }
    
    if ((ret = _srs_server->register_signal()) != ERROR_SUCCESS) {
        return ret;
    }
    
    if ((ret = _srs_server->http_handle()) != ERROR_SUCCESS) {
        return ret;
    }
    
    if ((ret = _srs_server->ingest()) != ERROR_SUCCESS) {
        return ret;
    }
    
    if ((ret = _srs_server->cycle()) != ERROR_SUCCESS) {
        return ret;
    }
    
    return 0;
}

进入客户监听

 if ((ret = _srs_server->listen()) != ERROR_SUCCESS) {
        return ret;
    }
 监听内容：  不同的连接请求，有不同的监听。 
int SrsServer::listen()
{
    int ret = ERROR_SUCCESS;
    // 创建一个rtmp的Streamlistener
    if ((ret = listen_rtmp()) != ERROR_SUCCESS) {
        return ret;
    }
    
    if ((ret = listen_http_api()) != ERROR_SUCCESS) {
        return ret;
    }
    
    if ((ret = listen_http_stream()) != ERROR_SUCCESS) {
        return ret;
    }
    
    if ((ret = listen_stream_caster()) != ERROR_SUCCESS) {
        return ret;
    }
    
    return ret;
}

1、首先分析RTMP连接 

int SrsServer::listen_rtmp()
{
    int ret = ERROR_SUCCESS;
    
    // stream service port.
    std::vector<std::string> ip_ports = _srs_config->get_listens();
    srs_assert((int)ip_ports.size() > 0);
    
    close_listeners(SrsListenerRtmpStream);
    
    for (int i = 0; i < (int)ip_ports.size(); i++) {
        SrsListener* listener = new SrsStreamListener(this, SrsListenerRtmpStream);
        listeners.push_back(listener);
        
        std::string ip;
        int port;
        srs_parse_endpoint(ip_ports[i], ip, port);
        
        if ((ret = listener->listen(ip, port)) != ERROR_SUCCESS) {
            srs_error("RTMP stream listen at %s:%d failed. ret=%d", ip.c_str(), port, ret);
            return ret;
        }
    }
    
    return ret;
}
        这里是listen_rtmp()函数，你也可以去看看listen_http_api()函数、listen_http_stream（）函数，其实结构都很相似，只是在创建SrsStreamListener对象时，传入了不同的参数SrsListenerRtmpStream、SrsListenerHttpApi、SrsListenerHttpStream，代表了不同类型的监听对象。 
// listen_rtmp 中listen监听走这里了。
int SrsStreamListener::listen(string i, int p)
{
    int ret = ERROR_SUCCESS;
    
    ip = i;
    port = p;

    srs_freep(listener);
    listener = new SrsTcpListener(this, ip, port);

    if ((ret = listener->listen()) != ERROR_SUCCESS) {
        srs_error("tcp listen failed. ret=%d", ret);
        return ret;
    }
    
    srs_info("listen thread current_cid=%d, "
        "listen at port=%d, type=%d, fd=%d started success, ep=%s:%d",
        _srs_context->get_id(), p, type, listener->fd(), i.c_str(), p);

    srs_trace("%s listen at tcp://%s:%d, fd=%d", srs_listener_type2string(type).c_str(), ip.c_str(), port, listener->fd());

    return ret;
}
注意，这里有大量纯虚函数，不要走错路了。进入TCP监听代码 
// rtmp tcp监听
int SrsTcpListener::listen()
{
//C++ Socket编程
    int ret = ERROR_SUCCESS;
    // 1、创建套接字，流式Socket(SOCK_STREAM)
    if ((_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        ret = ERROR_SOCKET_CREATE;
        srs_error("create linux socket error. port=%d, ret=%d", port, ret);
        return ret;
    }
    srs_verbose("create linux socket success. port=%d, fd=%d", port, _fd);
    
    int reuse_socket = 1;
    if (setsockopt(_fd, SOL_SOCKET, SO_REUSEADDR, &reuse_socket, sizeof(int)) == -1) {
        ret = ERROR_SOCKET_SETREUSE;
        srs_error("setsockopt reuse-addr error. port=%d, ret=%d", port, ret);
        return ret;
    }
    srs_verbose("setsockopt reuse-addr success. port=%d, fd=%d", port, _fd);
    
    sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = inet_addr(ip.c_str());
	// 2、绑定套接字到一个IP地址和一个端口上
    if (bind(_fd, (const sockaddr*)&addr, sizeof(sockaddr_in)) == -1) {
        ret = ERROR_SOCKET_BIND;
        srs_error("bind socket error. ep=%s:%d, ret=%d", ip.c_str(), port, ret);
        return ret;
    }
    srs_verbose("bind socket success. ep=%s:%d, fd=%d", ip.c_str(), port, _fd);
    // 3、将套接字设置为监听模式等待连接请求
    if (::listen(_fd, SERVER_LISTEN_BACKLOG) == -1) {
        ret = ERROR_SOCKET_LISTEN;
        srs_error("listen socket error. ep=%s:%d, ret=%d", ip.c_str(), port, ret);
        return ret;
    }
    srs_verbose("listen socket success. ep=%s:%d, fd=%d", ip.c_str(), port, _fd);
    
    if ((_stfd = st_netfd_open_socket(_fd)) == NULL){
        ret = ERROR_ST_OPEN_SOCKET;
        srs_error("st_netfd_open_socket open socket failed. ep=%s:%d, ret=%d", ip.c_str(), port, ret);
        return ret;
    }
    srs_verbose("st open socket success. ep=%s:%d, fd=%d", ip.c_str(), port, _fd);
    // 4、等到连接一个客户之后，开启一个新的线程
    if ((ret = pthread->start()) != ERROR_SUCCESS) {
        srs_error("st_thread_create listen thread error. ep=%s:%d, ret=%d", ip.c_str(), port, ret);
        return ret;
    }
    srs_verbose("create st listen thread success, ep=%s:%d", ip.c_str(), port);
    
    return ret;
}
       此代码为C++ TCP  Socket代码，思路比较清晰，可以看到，每接受到一个rtmp访问请求，创建一个”线程“，这里暂时将其称为线程，后面再做具体介绍。创建线程代码如下： 
int SrsReusableThread::start()
{
    return pthread->start();
}

int SrsThread::start()
{
    int ret = ERROR_SUCCESS;

    if(tid) {
        srs_info("thread %s already running.", _name);
        return ret;
    }
    if((tid = st_thread_create(thread_fun, this, (_joinable? 1:0), 0)) == NULL){
        ret = ERROR_ST_CREATE_CYCLE_THREAD;
	srs_error("st_thread_create failed. ret=%d", ret);
	return ret;
    }
    disposed = false;
    // we set to loop to true for thread to run.
    loop = true;
    // wait for cid to ready, for parent thread to get the cid.
    while (_cid < 0) {
        st_usleep(10 * 1000);
    }
    // now, cycle thread can run.
    can_run = true;
    return ret;
}

       来到了st_thread_create，这里要注意，这是SRS开源项目具有高并发，高性能的重要一步。这里创建的是协程，不是线程。协程是有别于进程和线程的一种组件，具有进程的独立性和线程的轻量级，听说微信能够支持8亿用户量，也是采用协程这种网络服务框架：http://www.infoq.com/cn/articles/CplusStyleCorourtine-At-Wechat。

从这里可以看出，srs是一个单线程的服务器，采用协程，主持高并发，高性能。

创建协程，协程函数为：thread_fun()

// 每连链接一个用户，创建一个协程程，该函数为协程函数
void* SrsThread::thread_fun(void* arg)
{
	SrsThread* obj = (SrsThread*)arg;
	srs_assert(obj);
	// 进入线程循环
	obj->thread_cycle();
	
	// for valgrind to detect.
	SrsThreadContext* ctx = dynamic_cast<SrsThreadContext*>(_srs_context);
	if (ctx) {
		ctx->clear_cid();
	}
	
	st_thread_exit(NULL);
	
	return NULL;
}
此时，真正进入了协程循环处理 
void SrsThread::thread_cycle()
    {
        int ret = ERROR_SUCCESS;
        
        _srs_context->generate_id();
        srs_info("thread %s cycle start", _name);
        
        _cid = _srs_context->get_id();
        
        srs_assert(handler);
        handler->on_thread_start();
        
        // thread is running now.
        really_terminated = false;
        
        // wait for cid to ready, for parent thread to get the cid.
        while (!can_run && loop) {
            st_usleep(10 * 1000);
        }
        
        while (loop) {
            if ((ret = handler->on_before_cycle()) != ERROR_SUCCESS) {
                srs_warn("thread %s on before cycle failed, ignored and retry, ret=%d", _name, ret);
                goto failed;
            }
            srs_info("thread %s on before cycle success", _name);
            // 注意纯虚函数的应用
            if ((ret = handler->cycle()) != ERROR_SUCCESS) {
                if (!srs_is_client_gracefully_close(ret) && !srs_is_system_control_error(ret)) {
                    srs_warn("thread %s cycle failed, ignored and retry, ret=%d", _name, ret);
                }
                goto failed;
            }
            srs_info("thread %s cycle success", _name);
            
            if ((ret = handler->on_end_cycle()) != ERROR_SUCCESS) {
                srs_warn("thread %s on end cycle failed, ignored and retry, ret=%d", _name, ret);
                goto failed;
            }
            srs_info("thread %s on end cycle success", _name);
            
        failed:
            if (!loop) {
                break;
            }
            
            // to improve performance, donot sleep when interval is zero.
            // @see: https://github.com/ossrs/srs/issues/237
            if (cycle_interval_us != 0) {
                st_usleep(cycle_interval_us);
            }
        }
        
        // readly terminated now.
        really_terminated = true;
        
        handler->on_thread_stop();
        srs_info("thread %s cycle finished", _name);
    }
       至此，一定要熟悉C++纯虚函数的引用，本人刚学了几天C++，对虚函数和纯虚函数在SRS源码中的应用很不习惯！  好了，进入循环ret = handler->cycle() 
int SrsConnection::cycle()
{
    int ret = ERROR_SUCCESS;
    
    _srs_context->generate_id();
    id = _srs_context->get_id();
    
    ip = srs_get_peer_ip(st_netfd_fileno(stfd));
    //srs_trace("ip:%s", ip);
    
    ret = do_cycle();
    
    // if socket io error, set to closed.
    if (srs_is_client_gracefully_close(ret)) {
        ret = ERROR_SOCKET_CLOSED;
    }
    
    // success.
    if (ret == ERROR_SUCCESS) {
        srs_trace("client finished.");
    }
    
    // client close peer.
    if (ret == ERROR_SOCKET_CLOSED) {
        srs_warn("client disconnect peer. ret=%d", ret);
    }

    return ERROR_SUCCESS;
}
进入ret=do_cycle()； 
// TODO: return detail message when error for client.
int SrsRtmpConn::do_cycle()
{
    int ret = ERROR_SUCCESS;
    
    srs_trace("RTMP client ip=%s", ip.c_str());

    rtmp->set_recv_timeout(SRS_CONSTS_RTMP_RECV_TIMEOUT_US);
    rtmp->set_send_timeout(SRS_CONSTS_RTMP_SEND_TIMEOUT_US);
    
    if ((ret = rtmp->handshake()) != ERROR_SUCCESS) {
        srs_error("rtmp handshake failed. ret=%d", ret);
        return ret;
    }
    srs_verbose("rtmp handshake success");
    
    if ((ret = rtmp->connect_app(req)) != ERROR_SUCCESS) {
        srs_error("rtmp connect vhost/app failed. ret=%d", ret);
        return ret;
    }
    srs_verbose("rtmp connect app success");
    
    // set client ip to request.
    req->ip = ip;
    
    // discovery vhost, resolve the vhost from config
    SrsConfDirective* parsed_vhost = _srs_config->get_vhost(req->vhost);
    if (parsed_vhost) {
        req->vhost = parsed_vhost->arg0();
    }
    
    srs_info("discovery app success. schema=%s, vhost=%s, port=%s, app=%s",
        req->schema.c_str(), req->vhost.c_str(), req->port.c_str(), req->app.c_str());
    
    if (req->schema.empty() || req->vhost.empty() || req->port.empty() || req->app.empty()) {
        ret = ERROR_RTMP_REQ_TCURL;
        srs_error("discovery tcUrl failed. "
            "tcUrl=%s, schema=%s, vhost=%s, port=%s, app=%s, ret=%d",
            req->tcUrl.c_str(), req->schema.c_str(), req->vhost.c_str(), req->port.c_str(), req->app.c_str(), ret);
        return ret;
    }
    
    // check vhost
    if ((ret = check_vhost()) != ERROR_SUCCESS) {
        srs_error("check vhost failed. ret=%d", ret);
        return ret;
    }
    srs_verbose("check vhost success.");
    
    srs_trace("connect app, "
        "tcUrl=%s, pageUrl=%s, swfUrl=%s, schema=%s, vhost=%s, port=%s, app=%s, args=%s", 
        req->tcUrl.c_str(), req->pageUrl.c_str(), req->swfUrl.c_str(), 
        req->schema.c_str(), req->vhost.c_str(), req->port.c_str(),
        req->app.c_str(), (req->args? "(obj)":"null"));
    
    // show client identity
    if(req->args) {
        std::string srs_version;
        std::string srs_server_ip;
        int srs_pid = 0;
        int srs_id = 0;
        
        SrsAmf0Any* prop = NULL;
        if ((prop = req->args->ensure_property_string("srs_version")) != NULL) {
            srs_version = prop->to_str();
        }
        if ((prop = req->args->ensure_property_string("srs_server_ip")) != NULL) {
            srs_server_ip = prop->to_str();
        }
        if ((prop = req->args->ensure_property_number("srs_pid")) != NULL) {
            srs_pid = (int)prop->to_number();
        }
        if ((prop = req->args->ensure_property_number("srs_id")) != NULL) {
            srs_id = (int)prop->to_number();
        }
        
        srs_info("edge-srs ip=%s, version=%s, pid=%d, id=%d", 
            srs_server_ip.c_str(), srs_version.c_str(), srs_pid, srs_id);
        if (srs_pid > 0) {
            srs_trace("edge-srs ip=%s, version=%s, pid=%d, id=%d", 
                srs_server_ip.c_str(), srs_version.c_str(), srs_pid, srs_id);
        }
    }
    
    ret = service_cycle();
    
    http_hooks_on_close();

    return ret;
}
行了，rtmp连接就到这里，要不然都快到rtmp流接受代码了，和系统启动越走越远了，rtmp流接受后面再分析。

2、再分析http-api连接，回到int SrsServer::listen()函数中，梳理http-api链接

int SrsServer::listen_http_api()
{
    int ret = ERROR_SUCCESS;
    
#ifdef SRS_AUTO_HTTP_API
    close_listeners(SrsListenerHttpApi);
    if (_srs_config->get_http_api_enabled()) {
        SrsListener* listener = new SrsStreamListener(this, SrsListenerHttpApi);
        listeners.push_back(listener);
        
        std::string ep = _srs_config->get_http_api_listen();
        
        std::string ip;
        int port;
        srs_parse_endpoint(ep, ip, port);
        
        if ((ret = listener->listen(ip, port)) != ERROR_SUCCESS) {
            srs_error("HTTP api listen at %s:%d failed. ret=%d", ip.c_str(), port, ret);
            return ret;
        }
    }
#endif
    
    return ret;
}
listen_http_api（）函数和listen_rtmp（）函数内容非常像，再走到listener->listen()里面看看，结果来到了 
int SrsStreamListener::listen(string i, int p)
{
    int ret = ERROR_SUCCESS;
    
    ip = i;
    port = p;

    srs_freep(listener);
    listener = new SrsTcpListener(this, ip, port);

    if ((ret = listener->listen()) != ERROR_SUCCESS) {
        srs_error("tcp listen failed. ret=%d", ret);
        return ret;
    }
    
    srs_info("listen thread current_cid=%d, "
        "listen at port=%d, type=%d, fd=%d started success, ep=%s:%d",
        _srs_context->get_id(), p, type, listener->fd(), i.c_str(), p);

    srs_trace("%s listen at tcp://%s:%d, fd=%d", srs_listener_type2string(type).c_str(), ip.c_str(), port, listener->fd());

    return ret;
}
和rtmp链接监听机制完全一样，只是type不同而已 
enum SrsListenerType 
{
    // RTMP client,
    SrsListenerRtmpStream       = 0,
    // HTTP api,
    SrsListenerHttpApi          = 1,
    // HTTP stream, HDS/HLS/DASH
    SrsListenerHttpStream       = 2,
    // UDP stream, MPEG-TS over udp.
    SrsListenerMpegTsOverUdp    = 3,
    // TCP stream, RTSP stream.
    SrsListenerRtsp             = 4,
    // TCP stream, FLV stream over HTTP.
    SrsListenerFlv              = 5,
};
我就看了两个链接监听，监听到此为止。
 

3、http api回调注册

回到run_master（）函数中，从_srs_server->http_handle()看起。

int SrsServer::http_handle()
{
    int ret = ERROR_SUCCESS;
    
#ifdef SRS_AUTO_HTTP_API
    srs_assert(http_api_mux);
    if ((ret = http_api_mux->handle("/", new SrsHttpNotFoundHandler())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/", new SrsGoApiApi())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/v1/", new SrsGoApiV1())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/v1/versions", new SrsGoApiVersion())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/v1/summaries", new SrsGoApiSummaries())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/v1/rusages", new SrsGoApiRusages())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/v1/self_proc_stats", new SrsGoApiSelfProcStats())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/v1/system_proc_stats", new SrsGoApiSystemProcStats())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/v1/meminfos", new SrsGoApiMemInfos())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/v1/authors", new SrsGoApiAuthors())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/v1/features", new SrsGoApiFeatures())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/v1/vhosts/", new SrsGoApiVhosts())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/v1/streams/", new SrsGoApiStreams())) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = http_api_mux->handle("/api/v1/clients/", new SrsGoApiClients())) != ERROR_SUCCESS) {
        return ret;
    }
    
    // test the request info.
    if ((ret = http_api_mux->handle("/api/v1/tests/requests", new SrsGoApiRequests())) != ERROR_SUCCESS) {
        return ret;
    }
    // test the error code response.
    if ((ret = http_api_mux->handle("/api/v1/tests/errors", new SrsGoApiError())) != ERROR_SUCCESS) {
        return ret;
    }
    // test the redirect mechenism.
    if ((ret = http_api_mux->handle("/api/v1/tests/redirects", new SrsHttpRedirectHandler("/api/v1/tests/errors", SRS_CONSTS_HTTP_MovedPermanently))) != ERROR_SUCCESS) {
        return ret;
    }
    // test the http vhost.
    if ((ret = http_api_mux->handle("error.srs.com/api/v1/tests/errors", new SrsGoApiError())) != ERROR_SUCCESS) {
        return ret;
    }
    
    // TODO: FIXME: for console.
    // TODO: FIXME: support reload.
    std::string dir = _srs_config->get_http_stream_dir() + "/console";
    if ((ret = http_api_mux->handle("/console/", new SrsHttpFileServer(dir))) != ERROR_SUCCESS) {
        srs_error("http: mount console dir=%s failed. ret=%d", dir.c_str(), ret);
        return ret;
    }
    srs_trace("http: api mount /console to %s", dir.c_str());
#endif

    return ret;
}

该函数注册了http-api回调接口。可以参考：https://github.com/ossrs/srs/wiki/v2_CN_HTTPApi

比如我们可以访问http://ip:1985/api/v1  其中ip为SRS服务器地址，就可以看到从该接口返回srs服务器参数。

4、ingest（拉流，SRS主动去拉流，和推流相反）处理

注意：SRS对拉流的处理比较特殊， SRS拉流是通过ffmpeg工具去实现的，SRS代码只是实现简单的系统调用，这部分内容在后面的章节中详细说明。 
int SrsIngester::start()
{
    int ret = ERROR_SUCCESS;
    
    if ((ret = parse()) != ERROR_SUCCESS) {
        clear_engines();
        ret = ERROR_SUCCESS;
        return ret;
    }
    
    // even no ingesters, we must also start it,
    // for the reload may add more ingesters.
    
    // start thread to run all encoding engines.
    if ((ret = pthread->start()) != ERROR_SUCCESS) {
        srs_error("st_thread_create failed. ret=%d", ret);
        return ret;
    }
    srs_trace("ingest thread cid=%d, current_cid=%d", pthread->cid(), _srs_context->get_id());
    
    return ret;
}
到此，可以看出，和监听过程一样，进入int SrsThread::start()函数，只是传入对象不一样而已。
 

5、SRS自服务

int SrsServer::cycle()
{
    int ret = ERROR_SUCCESS;
	srs_trace("SrsServer")

    ret = do_cycle();

#ifdef SRS_AUTO_GPERF_MC
    destroy();
    
    // remark, for gmc, never invoke the exit().
    srs_warn("sleep a long time for system st-threads to cleanup.");
    st_usleep(3 * 1000 * 1000);
    srs_warn("system quit");
#else
    // normally quit with neccessary cleanup by dispose().
    srs_warn("main cycle terminated, system quit normally.");
    dispose();
    srs_trace("srs terminated");
    
    // for valgrind to detect.
    srs_freep(_srs_config);
    srs_freep(_srs_log);
    
    exit(0);
#endif
    
    return ret;
}
int SrsServer::do_cycle()
{
    int ret = ERROR_SUCCESS;
    
    // find the max loop
    int max = srs_max(0, SRS_SYS_TIME_RESOLUTION_MS_TIMES);
    
#ifdef SRS_AUTO_STAT
    max = srs_max(max, SRS_SYS_RUSAGE_RESOLUTION_TIMES);
    max = srs_max(max, SRS_SYS_CPU_STAT_RESOLUTION_TIMES);
    max = srs_max(max, SRS_SYS_DISK_STAT_RESOLUTION_TIMES);
    max = srs_max(max, SRS_SYS_MEMINFO_RESOLUTION_TIMES);
    max = srs_max(max, SRS_SYS_PLATFORM_INFO_RESOLUTION_TIMES);
    max = srs_max(max, SRS_SYS_NETWORK_DEVICE_RESOLUTION_TIMES);
    max = srs_max(max, SRS_SYS_NETWORK_RTMP_SERVER_RESOLUTION_TIMES);
#endif
    
    // for asprocess.
    bool asprocess = _srs_config->get_asprocess();
    
    // the deamon thread, update the time cache
    while (true) {
        if(handler && (ret = handler->on_cycle((int)conns.size())) != ERROR_SUCCESS){
            srs_error("cycle handle failed. ret=%d", ret);
            return ret;
        }
            
        // the interval in config.
        int heartbeat_max_resolution = (int)(_srs_config->get_heartbeat_interval() / SRS_SYS_CYCLE_INTERVAL);
        
        // dynamic fetch the max.
        int temp_max = max;
        temp_max = srs_max(temp_max, heartbeat_max_resolution);
        
        for (int i = 0; i < temp_max; i++) {
            st_usleep(SRS_SYS_CYCLE_INTERVAL * 1000);
            
            // asprocess check.
            if (asprocess && ::getppid() != ppid) {
                srs_warn("asprocess ppid changed from %d to %d", ppid, ::getppid());
                return ret;
            }
            
            // gracefully quit for SIGINT or SIGTERM.
            if (signal_gracefully_quit) {
                srs_trace("cleanup for gracefully terminate.");
                return ret;
            }
        
            // for gperf heap checker,
            // @see: research/gperftools/heap-checker/heap_checker.cc
            // if user interrupt the program, exit to check mem leak.
            // but, if gperf, use reload to ensure main return normally,
            // because directly exit will cause core-dump.
#ifdef SRS_AUTO_GPERF_MC
            if (signal_gmc_stop) {
                srs_warn("gmc got singal to stop server.");
                return ret;
            }
#endif
        
            // do reload the config.
            if (signal_reload) {
                signal_reload = false;
                srs_info("get signal reload, to reload the config.");
                
                if ((ret = _srs_config->reload()) != ERROR_SUCCESS) {
                    srs_error("reload config failed. ret=%d", ret);
                    return ret;
                }
                srs_trace("reload config success.");
            }
            
            // notice the stream sources to cycle.
            if ((ret = SrsSource::cycle_all()) != ERROR_SUCCESS) {
                return ret;
            }
            
            // update the cache time
            if ((i % SRS_SYS_TIME_RESOLUTION_MS_TIMES) == 0) {
                srs_info("update current time cache.");
                srs_update_system_time_ms();
            }
            
#ifdef SRS_AUTO_STAT
            if ((i % SRS_SYS_RUSAGE_RESOLUTION_TIMES) == 0) {
                srs_info("update resource info, rss.");
                srs_update_system_rusage();
            }
            if ((i % SRS_SYS_CPU_STAT_RESOLUTION_TIMES) == 0) {
                srs_info("update cpu info, cpu usage.");
                srs_update_proc_stat();
            }
            if ((i % SRS_SYS_DISK_STAT_RESOLUTION_TIMES) == 0) {
                srs_info("update disk info, disk iops.");
                srs_update_disk_stat();
            }
            if ((i % SRS_SYS_MEMINFO_RESOLUTION_TIMES) == 0) {
                srs_info("update memory info, usage/free.");
                srs_update_meminfo();
            }
            if ((i % SRS_SYS_PLATFORM_INFO_RESOLUTION_TIMES) == 0) {
                srs_info("update platform info, uptime/load.");
                srs_update_platform_info();
            }
            if ((i % SRS_SYS_NETWORK_DEVICE_RESOLUTION_TIMES) == 0) {
                srs_info("update network devices info.");
                srs_update_network_devices();
            }
            if ((i % SRS_SYS_NETWORK_RTMP_SERVER_RESOLUTION_TIMES) == 0) {
                srs_info("update network server kbps info.");
                resample_kbps();
            }
    #ifdef SRS_AUTO_HTTP_CORE
            if (_srs_config->get_heartbeat_enabled()) {
                if ((i % heartbeat_max_resolution) == 0) {
                    srs_info("do http heartbeat, for internal server to report.");
                    http_heartbeat->heartbeat();
                }
            }
    #endif
#endif
            
            srs_info("server main thread loop");
        }
    }

    return ret;
}
主线程，更新srs时间和缓存！！至此，系统启动代码结构梳理完了。

三、总结

  • 启动不同的业务。
  • 监听不同的客户端类型。
  • 每链接一个客户端，SRS为其创建一个协程，专门负责该路链接信息交互。
  • SRS系统采用了协程网络服务框架，使得系统具有高并发，高性能等有点。
宇宙的尽头是编制
关注
  • 30
    点赞
  • 踩
  • 67
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
state-threads:为SRS修补的轻量级线程库，协程或c ++ goroutine
04-05
状态线程 从派生，针对修补。 参见： : 对于没有任何更改的原始ST，请签出。 用法 获取代码： git clone https://github.com/ossrs/state-threads.git && cd state-threads && git checkout srs 对于Linux： make linux-debug EXTRA_CFLAGS="-DMD_HAVE_EPOLL" 对于OSX： make darwin-debug EXTRA_CFLAGS="-DMD_HAVE_KQUEUE" 带有valgrindLinux： make linux-debug EXTRA_CFLAGS="-DMD_VALGRIND" 备注：用户必须安装valgrind，例如，在centos6 sudo yum install -y valgrind valgrind-deve
mac-local-rtmp-server：本地RTMP流服务器
02-04
适用于macOS的本地RTMP服务器 :warning_selector: 注意： Elgato发布了一个名为“ OBS Link”的程序，该程序执行相同的操作（以不同的方式）。 您可能想。 但是，我也注意到该方法存在相同的时滞。 这是用于macOS...
SRS服务器RTMP2WebRTC外网拉流配置
daze_scarecrow的博客
01-02 988
WebRTC包含信令(Signaling)和媒体(Media)两个部分的协议，信令默认使用1985端口，媒体默认使用UDP8000端口传输，无法单独修改发送给客户端的媒体端口，所以需要将8000端口改为和外网端口一致的端口33333。3、修改SRS配置文件，将rtc_server中监听的UDP端口8000改为33333，重启容器。将前端服务开放到外网，并且在外网使用WebRTC拉流，要求全部使用同一端口。2、docker创建SRS服务器，将开放的8000端口改为33333端口。
RTMP server 搭建的一种方法
西山竹的博客
06-15 6271
  RTMP SERVER   ubuntu    16.04 LTS   nginx-rtmp-module   CPU：双核  内存：4G    带宽：5Mb/s    http://blog.csdn.net/kingroc/article/details/50839994    参考链接  is OK    http://summervast.blog.51cto.com/690507/3...
推荐开源项目：SRS - 实时音视频服务器
gitblog_00014的博客
03-19 392
推荐开源项目：SRS - 实时音视频服务器 项目地址:https://gitcode.com/ossrs/srs 项目简介 SRS 是一个高性能、易部署的实时音视频服务器，由开放源代码社区 OSSRS.net 主导开发。SRS 专注于提供稳定的 RTMP、HLS 和 SRT 等流媒体服务，同时还支持 WebRTC、HTTP-FLV 等现代协议，以满足不同场景下的直播需求。 技术分析 高性能架构 S...
【SRS】流媒体服务器（推流+拉流+转流）
m0_60259116的博客
06-16 4417
【SRS】流媒体服务器（推流+拉流+转流）
利用Simple-RTMP-Server搭建RTMP和HLS直播服务（上）
LiveVideoStack
12-04 9467
SRS（Simple-RTMP-Server）定位是运营级的互联网直播服务器集群，追求更好的概念完整性和最简单实现的代码，在Github上人气颇高。本文是由王学投稿的SRS搭建直播的学习笔记，由LiveVideoStack整理并首发。 文 / 王学 整理 / LiveVideoStack 文章共6个部分，涉及SRS采集 、编码、录制、传输、解码等整套解决方案。
SRS(simple-rtmp-server)流媒体服务器源码分析--RTMP消息play
ManagerUser的博客
07-07 7021
SRS(simple-rtmp-server)流媒体服务器源码分析--RTMP消息play 前言：本章内容梳理SRS接受到rtmp信息之后，如何转发出去。同样这里先做代码梳理，本人也在源码熟悉之中，可能很多网友朋友最关心接受到rtmp之后，信息如果处理，如何缓存甚至如何转发给直播用户，这些内容目前还没有梳理完毕。 1、进入play流程     由于之前的博客中已经梳理了系统启
windows环境下，搭建RTMP视频推流服务器
朱豪凯的博客
03-27 1万+
介绍如何在windows环境下，如何快速地搭建RTMP服务器
SRS4.0源码分析-推流总结
u012117034的博客
04-12 2020
本文采用的 SRS 版本是 4.0-b8 ， 下载地址：github 本文主要对前面的文章做下总结。 《SRS4.0源码分析-main》，《SRS4.0源码分析-RTMP入口》，《SRS4.0源码分析-创建RTMP协程》，《SRS4.0源码分析-SrsRtmpConn::cycle》，《SRS4.0源码分析-SrsRtmpConn::stream_service_cycle》，《SRS4.0源码分析-SrsRecvThread::cycle》。 上面 7 篇 文章从 RTMP 入口，一直追踪到 推流数
无需中转平台，通过视频解码器RTMP Server服务实现低延时传输
千视KILOVIEW的博客
02-03 1344
RTMP Server是RTMP/HLS流媒体服务器，通过RTMP Server服务功能可以将视频编码器可以直接将视频流通过RTMP传输到解码器进行解码和输出，无需RTMP中转平台。 【教程】如何通过视频解码器RTMP Server服务实现低延时传输？ 传统业务模式下视频编码器直接推送RTMP网络流到视频解码器进行解码播放是不可以的，需要视频编码器推流RTMP到直播平台（或RTMP流媒体
SRS4.0源码分析-序言
u012117034的博客
04-11 2514
《SRS4.0源码分析》专栏，会从 configure（配置），makefile（编译规则），main （入口函数）， 带你一步一步了解 SRS 的主干代码逻辑。 这里分享一个本人阅读开源项目源码的技巧，大部分比较好的开源项目 模块划分都比较完善，初学者开始只需要了解主干逻辑，其他各个模块的细节用到的时候再仔细研究即可，不需要一开始就把全部的代码逻辑吃透，下面是ffmpeg项目的主干逻辑以及各个模块的分布。 开源项目动辄几十万行代码，如果没有好的模块划分，会很难维护，在早期就会死掉，所以一般活下..
免部署的Windows 平台下的nginx-rtmp-win32 流媒体服务器
05-24
免部署的Windows 平台下的nginx-rtmp-win32 流媒体服务器，直接解压运行nginx.exe 即可开启RTMP流媒体直播服务器功能，集直播和网页直播功能，内置web版的流媒体推流，播放工具，网页端口见配置文件nginx.conf
一款基于 nginx-rtmp-module 的流媒体服务器
04-17
基于nginx-rtmp-module的流媒体服务器。具备nginx-rtmp-module的所有功能，增加了HTTP-FLV，GOP缓存和VHOST（一个IP对应多个域名）的功能
基于nginx-rtmp-module的HTTP-FLV流媒体服务器设计源码
最新发布
04-15
基于nginx-rtmp-module的HTTP-FLV流媒体服务器设计源码，该项目包含101个文件，主要文件类型有40个c源文件，以及22个h头文件。此外，还包括10个Markdown文档用于项目说明，以及5个swf文件。该项目是一个基于nginx-...
nginx+nginx-rtmp-module的流媒体服务器搭建文件
12-29
nginx.conf配置详情
伯克利套接字（BSD Socket）
热门推荐
blueman2012的专栏
08-17 3万+
伯克利套接字 ----------维基百科，自由的百科全书   伯克利套接字（Berkeley sockets），也称为BSD Socket。伯克利套接字的应用编程接口（API）是采用C语言的进程间通信的库，经常用在计算机网络间的通信。 BSD Socket的应用编
Simple Rtmp Server的安装与简单使用
RedStarOfSleep's Blog
04-28 1万+
Simple Rtmp Server是一个国人编写的开源的RTMP/HLS流媒体服务器. 功能与nginx-rtmp-module类似, 可以实现rtmp/hls的分发.   有关nginx-rtmp-module的可参照: http://blog.csdn.net/redstarofsleep/article/details/45092147   编译与安装过程十分的简单     ./
SRS流媒体服务器安装配置
weixin_34368949的博客
07-17 8865
    SRS全称Simple RTMP Server，定位是运营级的互联网直播服务器集群，是一个非常简单就可以推送rtmp视频流的服务器.     github主页：https://github.com/ossrs/srs     目前稳定版为2.0，3.0版本正在开发中，2.0的文档为：https://github.com/ossrs/srs/wiki/v2_CN_Home，文档为中文版，里面...
Nginx-rtmp如何搭建流媒体服务器
05-22
要搭建一个基于 Nginx-rtmp 的流媒体服务器，可以按照以下步骤进行： 1. 安装 Nginx 和 Nginx-rtmp 模块 在 Linux 系统中，可以使用包管理器安装 Nginx 和 Nginx-rtmp 模块。以 Ubuntu 为例，可以使用以下命令进行安装： ``` sudo apt-get update sudo apt-get install nginx libnginx-mod-rtmp ``` 2. 配置 Nginx-rtmp 模块 打开 Nginx 配置文件 `/etc/nginx/nginx.conf`，添加以下配置： ``` rtmp { server { listen 1935; # RTMP 协议默认端口 chunk_size 4000; application live { live on; record off; } } } ``` 上面的配置定义了一个 RTMP 服务器，监听 1935 端口，并定义了一个名为 `live` 的应用，将直播流推送到该应用。 3. 启动 Nginx 服务 启动 Nginx 服务，使用以下命令： ``` sudo service nginx start ``` 4. 推送直播流 使用 OBS、FFmpeg 等工具推送直播流，将直播流推送到 `rtmp://localhost/live/stream_name`。其中 `stream_name` 是流的名称，可以自定义。 5. 播放直播流 使用播放器打开 `rtmp://localhost/live/stream_name`，即可播放直播流。 以上就是基于 Nginx-rtmp 模块搭建流媒体服务器的步骤。需要注意的是，Nginx-rtmp 模块并不支持 HLS 等其他协议，如果需要支持其他协议，可以考虑使用其他流媒体服务器软件，如 Wowza、Red5 等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值