流媒体协议分析之webrtc 协议 srs 服务器实现

已于 2022-12-13 09:03:36 修改
阅读量1.5k 收藏 3
点赞数 1
分类专栏： 流媒体分析 文章标签： webrtc 服务器 udp
于 2022-10-18 15:35:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012794472/article/details/127389192
版权

1.信令交互  ，sdp信令交互。

listen_udp : 注册udp 监听：

listen_api ：注册信令交互接口：

#ifdef SRS_RTC
    _srs_hybrid->register_server(new RtcServerAdapter());
#endif

srs_error_t RtcServerAdapter::run(SrsWaitGroup* wg)
{
    srs_error_t err = srs_success;

    if ((err = rtc->listen_udp()) != srs_success) {
        return srs_error_wrap(err, "listen udp");
    }

    if ((err = rtc->listen_api()) != srs_success) {
        return srs_error_wrap(err, "listen api");
    }

    if ((err = _srs_rtc_manager->start()) != srs_success) {
        return srs_error_wrap(err, "start manager");
    }

    return err;
}
srs_error_t SrsRtcServer::listen_udp()
{
    srs_error_t err = srs_success;

    if (!_srs_config->get_rtc_server_enabled()) {
        return err;
    }

    int port = _srs_config->get_rtc_server_listen();
    if (port <= 0) {
        return srs_error_new(ERROR_RTC_PORT, "invalid port=%d", port);
    }

    string ip = srs_any_address_for_listener();
    srs_assert(listeners.empty());

    int nn_listeners = _srs_config->get_rtc_server_reuseport();
    for (int i = 0; i < nn_listeners; i++) {
        SrsUdpMuxListener* listener = new SrsUdpMuxListener(this, ip, port);

        if ((err = listener->listen()) != srs_success) {
            srs_freep(listener);
            return srs_error_wrap(err, "listen %s:%d", ip.c_str(), port);
        }

        srs_trace("rtc listen at udp://%s:%d, fd=%d", ip.c_str(), port, listener->fd());
        listeners.push_back(listener);
    }

    return err;
}
srs_error_t SrsRtcServer::listen_api()
{
    srs_error_t err = srs_success;

    // TODO: FIXME: Fetch api from hybrid manager, not from SRS.
    ISrsHttpServeMux* http_api_mux = _srs_hybrid->srs()->instance()->api_server();

    if ((err = http_api_mux->handle("/rtc/v1/play/", new SrsGoApiRtcPlay(this))) != srs_success) {
        return srs_error_wrap(err, "handle play");
    }

    if ((err = http_api_mux->handle("/rtc/v1/publish/", new SrsGoApiRtcPublish(this))) != srs_success) {
        return srs_error_wrap(err, "handle publish");
    }

    // Generally, WHIP is a publishing protocol, but it can be also used as playing.
    if ((err = http_api_mux->handle("/rtc/v1/whip/", new SrsGoApiRtcWhip(this))) != srs_success) {
        return srs_error_wrap(err, "handle whip");
    }

    // We create another mount, to support play with the same query string as publish.
    if ((err = http_api_mux->handle("/rtc/v1/whip-play/", new SrsGoApiRtcWhip(this))) != srs_success) {
        return srs_error_wrap(err, "handle whip play");
    }

#ifdef SRS_SIMULATOR
    if ((err = http_api_mux->handle("/rtc/v1/nack/", new SrsGoApiRtcNACK(this))) != srs_success) {
        return srs_error_wrap(err, "handle nack");
    }
#endif

    return err;
}

SrsGoApiRtcPlay和SrsGoApiRtcPublish类，其对应的serve_http函数处理流程

serve_http 调用栈。

SrsHttpConn::SrsHttpConn(ISrsHttpConnOwner* handler, ISrsProtocolReadWriter* fd, ISrsHttpServeMux* m, string cip, int cport)
	new SrsSTCoroutine("http", this, _srs_context->get_id()); 创建协议，执行SrsSTCoroutine：cycle()
		SrsHttpConn::cycle()
			SrsHttpConn::do_cycle()
				SrsHttpConn::process_requests
					SrsHttpConn::process_request(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, int rid)
						srs_error_t SrsHttpCorsMux::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
							next->serve_http(w, r); //SrsHttpCorsMux::initialize 将next指向SrsHttpServeMux 对象
								rs_error_t SrsHttpServeMux::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
									SrsHttpServeMux::find_handler(ISrsHttpMessage* r, ISrsHttpHandler** ph)  找到字符串对应的回调函数
									h->serve_http

SrsGoApiRtcPublish 类serve_http函数处理：  创建SrsRtcConnection类，SrsRtcPublishStream类，SrsRtcSource 类。

SrsGoApiRtcPlay::serve_http
	SrsGoApiRtcPlay::do_serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, SrsJsonObject* res)
		srs_error_t SrsGoApiRtcPlay::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, SrsRtcUserConfig* ruc)
			server_->create_session(ruc, local_sdp, &session)) != srs_success)
				 SrsRtcServer::create_session(SrsRtcUserConfig* ruc, SrsSdp& local_sdp, SrsRtcConnection** psession)
					  SrsRtcConnection* session = new SrsRtcConnection(this, cid);
					  SrsRtcServer::do_create_session(SrsRtcUserConfig* ruc, SrsSdp& local_sdp, SrsRtcConnection* session)
						session->add_publisher
							 SrsRtcConnection::add_publisher(SrsRtcUserConfig* ruc, SrsSdp& local_sdp)
								 SrsRtcConnection::create_publisher(SrsRequest* req, SrsRtcSourceDescription* stream_desc)
									 SrsRtcPublishStream* publisher = new SrsRtcPublishStream(this, _srs_context->get_id());
									 _srs_rtc_sources->fetch_or_create(req, &source)
										SrsRtcSourceManager::fetch_or_create(SrsRequest* r, SrsRtcSource** pps)
											source = new SrsRtcSource();
											
											
srs_error_t SrsRtcSource::on_rtp(SrsRtpPacket* pkt)
{
    srs_error_t err = srs_success;

    // If circuit-breaker is dying, drop packet.
    if (_srs_circuit_breaker->hybrid_dying_water_level()) {
        _srs_pps_aloss2->sugar += (int64_t)consumers.size();
        return err;
    }

    for (int i = 0; i < (int)consumers.size(); i++) {
        SrsRtcConsumer* consumer = consumers.at(i);
        if ((err = consumer->enqueue(pkt->copy())) != srs_success) {
            return srs_error_wrap(err, "consume message");
        }
    }

    if (bridge_ && (err = bridge_->on_rtp(pkt)) != srs_success) {
        return srs_error_wrap(err, "bridge consume message");
    }

    return err;
}

SrsGoApiRtcPlay类的 serve_http 函数处理：创建：SrsRtcConnection类，SrsRtcPlayStream类，rSrsRtcConsumer类

SrsGoApiRtcPlay::serve_http
	SrsGoApiRtcPlay::do_serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, SrsJsonObject* res)
		srs_error_t SrsGoApiRtcPlay::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, SrsRtcUserConfig* ruc)
			server_->create_session(ruc, local_sdp, &session)) != srs_success)
				 SrsRtcServer::create_session(SrsRtcUserConfig* ruc, SrsSdp& local_sdp, SrsRtcConnection** psession)
					  SrsRtcConnection* session = new SrsRtcConnection(this, cid);
					  SrsRtcServer::do_create_session(SrsRtcUserConfig* ruc, SrsSdp& local_sdp, SrsRtcConnection* session)
						session->add_player
							SrsRtcConnection::add_player(SrsRtcUserConfig* ruc, SrsSdp& local_sdp)
								SrsRtcConnection::create_player(SrsRequest* req, std::map<uint32_t, SrsRtcTrackDescription*> sub_relations)
									SrsRtcPlayStream* player = new SrsRtcPlayStream(this, _srs_context->get_id());
		
开始执行函数					
SrsRtcPlayStream::start()
	trd_ = new SrsFastCoroutine("rtc_sender", this, cid_);  创建协程：执行传入SrsRtcPlayStream类cycle函数。
	trd_->start()
srs_error_t SrsRtcPlayStream::cycle()
{
    srs_error_t err = srs_success;

    SrsRtcSource* source = source_;

    SrsRtcConsumer* consumer = NULL;
    SrsAutoFree(SrsRtcConsumer, consumer);
    if ((err = source->create_consumer(consumer)) != srs_success) {
        return srs_error_wrap(err, "create consumer, source=%s", req_->get_stream_url().c_str());
    }

    srs_assert(consumer);
    consumer->set_handler(this);

    // TODO: FIXME: Dumps the SPS/PPS from gop cache, without other frames.
    if ((err = source->consumer_dumps(consumer)) != srs_success) {
        return srs_error_wrap(err, "dumps consumer, url=%s", req_->get_stream_url().c_str());
    }

    realtime = _srs_config->get_realtime_enabled(req_->vhost, true);
    mw_msgs = _srs_config->get_mw_msgs(req_->vhost, realtime, true);

    // TODO: FIXME: Add cost in ms.
    SrsContextId cid = source->source_id();
    srs_trace("RTC: start play url=%s, source_id=%s/%s, realtime=%d, mw_msgs=%d", req_->get_stream_url().c_str(),
        cid.c_str(), source->pre_source_id().c_str(), realtime, mw_msgs);

    SrsErrorPithyPrint* epp = new SrsErrorPithyPrint();
    SrsAutoFree(SrsErrorPithyPrint, epp);

    while (true) {
        if ((err = trd_->pull()) != srs_success) {
            return srs_error_wrap(err, "rtc sender thread");
        }

        // Wait for amount of packets.
        SrsRtpPacket* pkt = NULL;
        consumer->dump_packet(&pkt);
        if (!pkt) {
            // TODO: FIXME: We should check the quit event.
            consumer->wait(mw_msgs);
            continue;
        }

        // Send-out the RTP packet and do cleanup
        // @remark Note that the pkt might be set to NULL.
        if ((err = send_packet(pkt)) != srs_success) {
            uint32_t nn = 0;
            if (epp->can_print(err, &nn)) {
                srs_warn("play send packets=%u, nn=%u/%u, err: %s", 1, epp->nn_count, nn, srs_error_desc(err).c_str());
            }
            srs_freep(err);
        }

        // Free the packet.
        // @remark Note that the pkt might be set to NULL.
        srs_freep(pkt);
    }
}

 上面流程经过sdp 交换：

SDP交换与ICE建立连接
上面的过程只创建了针对WebRTC服务的关键对象，接下来需要分析，推拉流客户端与WebRTC服务的监听端口(8000)之间如何建立连接。WebRTC客户端与服务端之间的连接建立方式采用了类P2P私网穿透的方式。这种方式的一个最大特点就是一个WebRTC客户端向服务端发起连接请求时，事先并不知道服务端的IP地址和端口号，所以WebRTC连接建立一般包括两个阶段：
1）WebRTC客户端与服务端之间以offer和answer的方式交换包含各自IP地址+端口号信息的SDP(Session Description Protocol)报文。
2）WebRTC客户端从服务端SDP报文中获取服务端的IP地址和端口号，并以ICE(Interactive Connectivity Establishment)方式，在客户端和服务端之间建立连接，用于后续音视频数据的传输。
网上关于SDP和ICE的资料比较多，可根据需要学习、参考
https://segmentfault.com/a/1190000038272539 WebRTC SDP 详解和剖析
https://segmentfault.com/a/1190000020794391?utm_source=sf-similar-article WebRTC会话描述协议（SDP）详解
https://zhuanlan.zhihu.com/p/60684464 WebRTC 之ICE浅谈

下面是浏览器发送给SRS服务器的offer SDP，因为是trickle模式，所以SDP中没有包含客户端的IP地址，当然这并不影响最终的连接建立。

v=0
o=- 6308787264381624235 2 IN IP4 127.0.0.1
s=-
t=0 0
a=group:BUNDLE 0 1
m=audio 9 UDP/TLS/RTP/SAVPF 111 103 104 9 0 8 106 105 13 110 112 113 126
a=ice-options:trickle
a=sendonly
m=video 9 UDP/TLS/RTP/SAVPF 96 97 98 99 100 101 102 121 127 120 125 107 108 109 35 36 124 119 123
a=ice-options:trickle
a=sendonly



SRS服务端响应的answer SDP，其中candidate属性包含了SRS服务器的IP地址和端口描述信息(192.168.9.102 8000)，并且服务端采用ice-lite模式简化了ICE协商过程。

v=0
o=SRS/4.0.140(Leo) 32138128 2 IN IP4 0.0.0.0
s=SRSPublishSession
t=0 0
a=ice-lite
a=group:BUNDLE 0 1
m=audio 9 UDP/TLS/RTP/SAVPF 111
a=recvonly
a=candidate:0 1 udp 2130706431 192.168.9.102 8000 typ host generation 0
m=video 9 UDP/TLS/RTP/SAVPF 125 124
a=recvonly
a=candidate:0 1 udp 2130706431 192.168.9.102 8000 typ host generation 0



接下来，浏览器向SRS服务器的8000端口发送一个Binding Request报文，服务器给浏览器回一个Binding Success Response响应。最终，推拉流客户端与SRS服务器(8000端口)建立连接。

2. webrtc 通信，通过SDP，知道了udp 通信端口。

listen_udp
	SrsUdpMuxListener->listen  
		trd = new SrsSTCoroutine("udp", this, cid); 创建协程：执行传入SrsUdpMuxListener类cycle函数。
			 SrsUdpMuxListener::cycle()
				skt.recvfrom
				handler->on_udp_packet(&skt); 处理
					SrsRtcServer::on_udp_packet(SrsUdpMuxSocket* skt)
srs_error_t SrsRtcServer::on_udp_packet(SrsUdpMuxSocket* skt)
{
    srs_error_t err = srs_success;

    SrsRtcConnection* session = NULL;
    char* data = skt->data(); int size = skt->size();
    bool is_rtp_or_rtcp = srs_is_rtp_or_rtcp((uint8_t*)data, size);
    bool is_rtcp = srs_is_rtcp((uint8_t*)data, size);

    uint64_t fast_id = skt->fast_id();
    // Try fast id first, if not found, search by long peer id.
    if (fast_id) {
        session = (SrsRtcConnection*)_srs_rtc_manager->find_by_fast_id(fast_id);
    }
    if (!session) {
        string peer_id = skt->peer_id();
        session = (SrsRtcConnection*)_srs_rtc_manager->find_by_id(peer_id);
    }

    if (session) {
        // When got any packet, the session is alive now.
        session->alive();
    }

    // For STUN, the peer address may change.
    if (!is_rtp_or_rtcp && srs_is_stun((uint8_t*)data, size)) {
        ++_srs_pps_rstuns->sugar;
        string peer_id = skt->peer_id();

        // TODO: FIXME: Should support ICE renomination, to switch network between candidates.
        SrsStunPacket ping;
        if ((err = ping.decode(data, size)) != srs_success) {
            return srs_error_wrap(err, "decode stun packet failed");
        }
        if (!session) {
            session = find_session_by_username(ping.get_username());
        }
        if (session) {
            session->switch_to_context();
        }

        printf("recv stun packet from %s, fast=%" PRId64 ", use-candidate=%d, ice-controlled=%d, ice-controlling=%d\n",
            peer_id.c_str(), fast_id, ping.get_use_candidate(), ping.get_ice_controlled(), ping.get_ice_controlling());

        // TODO: FIXME: For ICE trickle, we may get STUN packets before SDP answer, so maybe should response it.
        if (!session) {
            return srs_error_new(ERROR_RTC_STUN, "no session, stun username=%s, peer_id=%s, fast=%" PRId64,
                ping.get_username().c_str(), peer_id.c_str(), fast_id);
        }

        // For each binding request, update the UDP socket.
        if (ping.is_binding_request()) {
            session->udp()->update_sendonly_socket(skt);
        }

        return session->udp()->on_stun(&ping, data, size);
    }
    printf("recv stun packet  fast=%" PRId64 " \n",fast_id);
    // For DTLS, RTCP or RTP, which does not support peer address changing.
    if (!session) {
        string peer_id = skt->peer_id();
        printf("%s %d\n",__FUNCTION__,__LINE__);
        return srs_error_new(ERROR_RTC_STUN, "no session, peer_id=%s, fast=%" PRId64, peer_id.c_str(), fast_id);
    }

    // Note that we don't(except error) switch to the context of session, for performance issue.
    if (is_rtp_or_rtcp && !is_rtcp) {
        ++_srs_pps_rrtps->sugar;

        err = session->udp()->on_rtp(data, size);
        if (err != srs_success) {
            session->switch_to_context();
        }
        return err;
    }

    session->switch_to_context();
    if (is_rtp_or_rtcp && is_rtcp) {
        ++_srs_pps_rrtcps->sugar;

        return session->udp()->on_rtcp(data, size);
    }
    if (srs_is_dtls((uint8_t*)data, size)) {
        ++_srs_pps_rstuns->sugar;

        return session->udp()->on_dtls(data, size);
    }
    return srs_error_new(ERROR_RTC_UDP, "unknown packet");
}

函数

  1. 客户端和服务端通过STUN协议和ICE机制建立连接
  2. 客户端和服务端通过DTLS协议报文完成安全认证并生成SRTP加解密所需的密钥
  3. 客户端和服务端之间通过SRTP算法实现RTP报文的加解密
  4. 客户端和服务端之间通过RTCP报文完成音视频数据的Qos处理
dongfangxingyu1
关注
专栏目录
srs4.0 webrtc 分析（三） 推流
lcalqf的专栏
02-01 3440
设计方案 详情见：https://github.com/rtcdn/rtcdn-draft 基于http接口以json格式上传webrtc建接所有的SDP信息 代码分析 首先看下推流端rtc_publisher.html 模块，文件在trunk\research\players目录下 代码逻辑 创建RTCPeerConnection 设置音视频收发方式与参数信息，contraints设置了视频最大高度 获得媒体流 创建offer sdp，并把该sdp设置为本地描述信息 通过post 接口，把offer s
SRS4.0源代码分析之WebRTC服务总体介绍
irainsa的博客
04-04 697
WebRTC是一个开放的Web标准，用于支持在浏览器之间的语音、视频和通用数据的双向实时通信。在以Google为首的大厂推动下，WebRTC各项技术逐渐成熟并标准化，成为各种主流浏览器都支持的基于Web的实时音视频通信解决方案。WebRTC本身是一个应用在客户端的类P2P技术，SRS4.0引入WebRTC处理能力，主要是为了构建服务器的SFU能力（什么是SFU读者可自行搜索）。这里借用一个网图来说明SFU的工作原理：如上图所示，对于视频会议场景，一般都有多个WebRTC客户端。
SRS流媒体服务器——WebRTC推拉流演示
热门推荐
努力努力再努力L
04-14 1万+
SRS流媒体服务器——WebRTC推拉流 目录 WebRTC推拉流配置 WebRTC拉流演示 WebRTC推流演示 SRS官方WebRTC文档：https://github.com/ossrs/srs/wiki/v4_CN_WebRTC#rtmp-to-rtc 1. WebRTC推拉流配置 webrtc是默认⽀持的（–rtc=on），使⽤默认的rtc配置(conf/rtc2rtmp.conf)就可以运行。 默认rtc2rtmp.conf配置如下： listen 19
搭建SRS实现WebRTC播放
igocsdn的博客
08-09 2778
浏览器中使用WebRTC方式实现视频流低延迟的无插件播放的技术方案。 WebRTC需要SRS的最低版本：SRS4.0.14，所以我们部署的srs的时候版本需要大于SRS4.0.14。 SRS4.0.14，支持了RTMP推流，WebRTC播放。 SRS部署安装 进入指定目录，进行下载 wget https://github.com/ossrs/srs/archive/v4.0.76.tar.gz 解压 tar -zxvf srs-4.0.76.tar.gz 进入目录 cd /usr/local/srs
基于SRS的WebRTC环境搭建
wel_006的博客
09-10 944
在音视频领域，WebRTC 是一个关键的技术，开源srs和zlMediaKit中都含有这一块的代码，对于想要深入学习 WebRTC 的人来说，实际运行 Demo 并分析代码是非常重要的。这种实践可以帮助你更好地理解 WebRTC 的工作原理、解决实际问题并获得自己的见解，废话不说，直接行动。
用SRS搭建WebRTC流媒体服务器
liveweb视频汇聚平台
10-09 849
WebRTC经过这么多年的发展，目前已经比较成熟的协议之一，播放也比较稳定，协议也已经成为了RFC，相应的开源项目也越来越多，但是基于WebRTC协议的部署简单，性能强悍，功能强大流媒体服务器的项目还比较稀少。本文福利， C++音视频学习资料包、技术视频，内容包括（音视频开发，面试题，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）↓↓↓↓↓↓见下面↓↓文章底部↓↓。./objs/srs -c conf/srs.conf // 启动srs。
srs配置WebRTC
a18796007675的博客
08-07 3606
1. WebRTC简介 由Google发起的实时通讯解决方案，其中包含视音频采集，编解码，数据传输，和音视频展示等功能 不光支持Web之间的音视频通讯，还支持Android以及IOS端，此外由于该项目是开源的，我们也可以通过编译C++代码，从而达到全平台的互通 Web开发者可以基于集成WebRTC的浏览器提供的web API开发基于视频、音频的实时通信应用。 WebRTC基于UDP 2. SRS配置WebRTC srs4.0开始陆续支持WebRTC的推流和播放功能 发展如下所示 SRS 4.0.14，
用SRS搭建WebRTC流媒体服务器实战
m0_60259116的博客
07-13 4102
用SRS搭建WebRTC流媒体服务器实战
SRS搭建webrtc直播一条龙教学！！！！！！
Lemon_D1999的博客
11-22 4845
SRS对直播和RTC这两种能力的抽象，是流(Stream)，一个流会有多个消费者(Consumer)，流之间没有关联。基于这些业务能力，我们提供了各种场景下的DEMO，比如低延迟直播、一对一通话、多人通话、连麦等等。WebRTC是通信的能力，从技术上看是两个或多个客户端，让用户具备互动的能力。人对于延迟的感知是400ms，也就是一般的对话能顺利进行，这是RTC的核心指标。直播和RTC的协议或能力，是SRS的核心能力，新的音视频开发者，将不会区分直播和RTC，因为都是互联网视频能力。启动srs成功后，我们。
基于SRS开源流媒体服务器的WebRTC直播与聊天网页应用设计源码
最新发布
10-05
该项目是一款基于SRS开源流媒体服务器的定制化WebRTC直播与聊天网页应用设计源码，共包含65个文件，涉及30个JavaScript文件、12个HTML文件、6个映射文件、3个ActionScript文件、2个项目文件、2个配置文件、1个Git...
Android WebRTC 拉取SRS 服务端视频流播放视频
01-18
WebRTC通常用于P2P通信，但也可以与RTMP服务器结合，实现从服务器获取流媒体内容。 首先，我们需要在Android项目中集成WebRTC库。可以通过在build.gradle文件中添加以下依赖来引入： ```groovy dependencies { ...
srs服务用于测试webrtc推流是否成功
07-03
SRS（Simple Real-time Streaming）是一个高性能、轻量级的实时流媒体服务器，广泛应用于直播、视频会议等领域，且支持WebRTC协议。本文将详细阐述SRS服务如何用于测试WebRTC推流的成功性。 1. **WebRTC简介** ...
【音视频开发系列】srs-webrtc-janus开源流媒体服务器分析
Linuxhus的博客
12-28 1018
全球最牛开源流媒体服务器源码分析 1.如何学习流媒体服务器 2.全球最牛流媒体服务器架构分析 3.我们能从全球最牛流媒体服务器得到什么 【音视频开发系列】srs-webrtc-janus流媒体服务器分析 更多精彩内容包括:C/C++，Linux，Nginx，ZeroMQ，MySQL，Redis，MongoDB，ZK，流媒体，P2P，Linux内核，Docker，TCP/IP，协程，DPDK多个高级知识点分享。 点击：https://ke.qq.com/course/417774?flowTok..
srs webrtc前端拉流播放（附带测试地址）
03-09
SRS（Simple Real-Time Streaming）是一个高性能、灵活的开源流媒体服务器，广泛应用于实时视频直播场景。在这个场景中，我们将探讨如何使用SRS与WebRTC结合，实现在前端拉取流并进行播放。 首先，了解WebRTC的基本...
srs中使用webrtc
sun007700的专栏
12-25 1125
srs部署/webrtc拉流 https://www.cnblogs.com/ziyue7575/p/13927894.html https://www.cnblogs.com/dong1/p/12712229.html https://github.com/ossrs/srs/wiki/v4_CN_Home https://github.com/ossrs/srs/blob/4.0release/trunk/doc/README.md
9、SRS4.0源代码分析之WebRTC服务总体介绍
黑板报
10-09 3605
SRS4.0源代码分析之WebRTC整体流程
SRS流媒体服务（四）WebRTC实现实时视频通话和低延时互动直播
weixin_44341110的博客
08-17 4854
使用webRTC API实现实时的视频通话和低延时互动直播
浏览器使用 webRTC 向 Srs流媒体服务器推流
qq_51677409的博客
08-07 1794
TIP : 核心就在于客户端创建 PeerConnection 对象, 给服务发 Offer 信息, 服务器响应 Answer 后建立网络连接。现在我们需要手动进入 WebRTC 推流, 我们应该怎么做?里面给了一个 publish 的示例, 我们根据这个改动。
探索实时通信的新维度：WebRTC-SRS
gitblog_00084的博客
04-04 397
探索实时通信的新维度：WebRTC-SRS 去发现同类优质开源项目:https://gitcode.com/ 在数字化的时代，实时音视频通信已经成为许多应用的核心功能，如在线教育、远程医疗、视频会议等。为此，我们向您推荐一个强大的开源项目——，这是一个由中国开发者维护的高效、灵活且易用的实时通信服务器系统。 WebRTC-SRS 是什么？ WebRTC-SRS 是基于 SRS（Simple Rea...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值