WebRTC 源码解析:应用层 API 功能实现
深入解析 WebRTC 源码架构,重点介绍应用层如何通过核心 API(getUserMedia、RTCPeerConnection 等)实现音视频通信。文章梳理了 API 层与核心引擎层的交互流程,包括媒体流获取、连接建立、SDP 协商及 ICE 候选交换。同时剖析了关键 C++ 源码文件(如 peerconnectioninterface.h)的结构与作用,并详细阐述了信令机制在会话建立中的原理与异常处理策略。

深入解析 WebRTC 源码架构,重点介绍应用层如何通过核心 API(getUserMedia、RTCPeerConnection 等)实现音视频通信。文章梳理了 API 层与核心引擎层的交互流程,包括媒体流获取、连接建立、SDP 协商及 ICE 候选交换。同时剖析了关键 C++ 源码文件(如 peerconnectioninterface.h)的结构与作用,并详细阐述了信令机制在会话建立中的原理与异常处理策略。

WebRTC 为应用层提供了四个核心 API,这些 API 是构建实时通信应用的基础:
| API | 功能 | 关键作用 | 浏览器兼容性 |
|---|---|---|---|
getUserMedia | 获取本地音视频流 | 访问摄像头、麦克风等硬件设备 | Chrome, Firefox, Edge, Safari |
RTCPeerConnection | 建立点对点连接 | 管理连接、交换媒体数据、处理 ICE 候选 | Chrome, Firefox, Edge, Safari |
RTCDataChannel | 传输任意数据 | 实现文本、文件等非媒体数据传输 | Chrome, Firefox, Edge |
getDisplayMedia | 获取屏幕共享流 | 实现屏幕共享功能 | Chrome, Firefox |
WebRTC API 位于API 层,是应用层与核心引擎层之间的桥梁。应用层通过调用这些 API,无需了解底层实现细节,即可实现复杂的实时通信功能。
WebRTC API 本质上是 JavaScript 接口,它封装了底层 WebRTC 核心引擎的功能。当应用层调用这些 API 时,WebRTC 引擎会执行以下操作:
核心功能定位
| 功能 | 说明 | 重要性 |
|---|---|---|
| 标准化接口 | 提供统一的 WebRTC API,使开发者无需关心底层实现 | ⭐⭐⭐⭐⭐ |
| 复杂性封装 | 将 ICE 候选收集、SDP 协商、媒体处理等复杂逻辑封装 | ⭐⭐⭐⭐ |
| 生命周期管理 | 管理 RTCPeerConnection 等对象的创建、使用和销毁 | ⭐⭐⭐⭐ |
| 跨平台支持 | 确保不同浏览器提供一致的 API 体验 | ⭐⭐⭐ |
| 错误处理 | 提供标准化的错误处理机制 | ⭐⭐⭐ |
WebRTC 应用开发的完整流程可以概括为'获取媒体→建立连接→交换信令→处理媒体→数据传输'五个核心步骤:
应用层 │ ├── 1. 获取本地媒体流 (getUserMedia) │ ├── 2. 创建 RTCPeerConnection 实例 (RTCPeerConnection) │ ├── 3. 信令交换 (SDP 与 ICE 候选) │ ├── 3.1 创建 Offer │ ├── 3.2 发送 Offer 给对方 │ ├── 3.3 接收 Answer │ └── 3.4 交换 ICE 候选 │ ├── 4. 处理媒体流 (ontrack 事件) │ └── 5. 数据传输 (RTCDataChannel)
WebRTC 源码中 API 层主要位于 api/ 目录下:
api/
├── peerconnectioninterface.h
├── peerconnectionfactoryinterface.h
├── mediastreaminterface.h
├── datachannelinterface.h
├── sdp.h
├── ...
pc/
├── peerconnectioninterface.cc
├── peerconnectionfactory.cc
├── ...
peerconnectioninterface.h - 核心接口// api/peerconnectioninterface.h
// RTCPeerConnection 的核心接口定义
class RTCPeerConnectionInterface {
public:
// 创建 offer
virtual void CreateOffer(CreateSessionDescriptionObserver* observer,
const RTCOfferOptions* options) = 0;
// 创建 answer
virtual void CreateAnswer(CreateSessionDescriptionObserver* observer,
const RTCOfferOptions* options) = 0;
// 设置远程描述
virtual void SetRemoteDescription(SetSessionDescriptionObserver* observer,
const SessionDescriptionInterface* desc) = 0;
// 设置本地描述
virtual void SetLocalDescription(SetSessionDescriptionObserver* observer,
const SessionDescriptionInterface* desc) = 0;
// 添加媒体轨道
virtual void AddTrack(const rtc::scoped_refptr<MediaStreamTrackInterface>& track,
const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) = 0;
// 添加 ICE 候选
= ;
= ;
= ;
= ;
};
CreateSessionDescriptionObserver 等接口用于处理异步操作peerconnectionfactoryinterface.h - 工厂接口// api/peerconnectionfactoryinterface.h
// PeerConnectionFactory 的接口定义
class PeerConnectionFactoryInterface {
public:
// 创建 PeerConnection 对象
virtual rtc::scoped_refptr<RTCPeerConnectionInterface> CreatePeerConnection(
const PeerConnectionInterface::Options& options,
const PeerConnectionInterface::RTCConfiguration& config,
const std::vector<rtc::scoped_refptr<PeerConnectionInterface::IceServer>>& ice_servers) = 0;
// 创建 DataChannel
virtual rtc::scoped_refptr<RTCDataChannelInterface> CreateDataChannel(
const std::string& label, const DataChannelInterface::Init& config) = 0;
// 创建 MediaStream
virtual rtc::scoped_refptr<MediaStreamInterface> CreateLocalMediaStream(
const std::string& label) = 0;
// 创建 MediaStreamTrack
virtual rtc::scoped_refptr<MediaStreamTrackInterface> CreateVideoTrack(
const std::string& id, VideoTrackSourceInterface* source) = 0;
// ... 其他方法
};
CreatePeerConnection 是创建 RTCPeerConnection 的入口scoped_refptr 管理对象生命周期,避免内存泄漏RTCConfiguration 用于配置 ICE 服务器等连接参数mediastreaminterface.h - 媒体流接口// api/mediastreaminterface.h
// MediaStream API 的核心接口
class MediaStreamInterface {
public:
// 获取媒体流 ID
virtual std::string id() const = 0;
// 获取媒体轨道列表
virtual const std::vector<rtc::scoped_refptr<MediaStreamTrackInterface>>& GetAudioTracks() const = 0;
virtual const std::vector<rtc::scoped_refptr<MediaStreamTrackInterface>>& GetVideoTracks() const = 0;
// 添加媒体轨道
virtual void AddTrack(const rtc::scoped_refptr<MediaStreamTrackInterface>& track) = 0;
// 移除媒体轨道
virtual void RemoveTrack(const rtc::scoped_refptr<MediaStreamTrackInterface>& track) = 0;
};
// MediaStreamTrack 的核心接口
class MediaStreamTrackInterface {
public:
// 获取轨道 ID
virtual std::string id() const = 0;
// 获取轨道类型
virtual std::string = ;
= ;
= ;
};
getUserMedia() API 最终会调用这些接口MediaStreamTrack 是媒体流的基本单元,可以是音频或视频sdp.h - SDP 处理接口// api/sdp.h
// SDP 处理核心接口
class SessionDescriptionInterface {
public:
// 获取 SDP 类型
virtual SdpType type() const = 0;
// 获取 SDP 内容
virtual std::string ToString() const = 0;
// 获取 SDP 的媒体描述
virtual const std::vector<MediaDescriptionInterface*>& GetMediaDescriptions() const = 0;
};
// SDP 解析器接口
class SdpParseError {
public:
// 错误类型
enum Type { kNoError, kInvalidFormat, kInvalidMLine, kInvalidAttribute /*...*/ };
};
// SDP 解析器
class SdpParse {
public:
// 解析 SDP 字符串
static rtc::scoped_refptr<SessionDescriptionInterface> ParseSdp(
const std::string& sdp, SdpParseError* error);
// 生成 SDP 字符串
static std::string GenerateSdp(const SessionDescriptionInterface* desc);
};
SdpParse 类负责 SDP 的解析和生成SessionDescriptionInterface 是 SDP 的抽象表示peerconnectioninterface.cc - 实现层// pc/peerconnectioninterface.cc
// RTCPeerConnection 的实现
class PeerConnection : public RTCPeerConnectionInterface {
public:
PeerConnection(const PeerConnectionInterface::Options& options,
const PeerConnectionInterface::RTCConfiguration& config,
const std::vector<rtc::scoped_refptr<IceServer>>& ice_servers) {
Initialize(options, config, ice_servers);
}
// 创建 offer
void CreateOffer(CreateSessionDescriptionObserver* observer,
const RTCOfferOptions* options) override {
// 1. 创建 SDP Offer
SessionDescriptionInterface* offer = CreateOfferInternal(options);
// 2. 设置本地描述
if (offer) SetLocalDescriptionInternal(offer);
// 3. 通过 Observer 返回结果
if (observer) observer->OnSuccess(offer);
}
// 设置本地描述
void SetLocalDescription(SetSessionDescriptionObserver* observer,
const SessionDescriptionInterface* desc) override {
// 1. 更新本地描述状态
local_desc_ = desc;
// 2. 生成 ICE 候选
GenerateIceCandidates();
// 3. 通知核心引擎
core_engine_->SetLocalDescription(desc);
// 4. 通过 Observer 通知应用层
if (observer) observer->OnSuccess();
}
{
ice_candidates_.(candidate);
core_engine_->(candidate);
}
:
SessionDescriptionInterface* local_desc_ = ;
SessionDescriptionInterface* remote_desc_ = ;
std::vector<rtc::scoped_refptr<IceCandidateInterface>> ice_candidates_;
std::unique_ptr<CoreEngine> core_engine_;
{
core_engine_ = std::<CoreEngine>(config, ice_servers);
}
};
PeerConnection 类实现了 RTCPeerConnectionInterface 接口core_engine_ 进行实际操作scoped_refptr 管理对象生命周期Observer 模式处理异步操作peerconnectionfactory.cc - 工厂实现// pc/peerconnectionfactory.cc
// PeerConnectionFactory 的实现
class PeerConnectionFactory : public PeerConnectionFactoryInterface {
public:
// 创建 PeerConnection
rtc::scoped_refptr<RTCPeerConnectionInterface> CreatePeerConnection(
const PeerConnectionInterface::Options& options,
const PeerConnectionInterface::RTCConfiguration& config,
const std::vector<rtc::scoped_refptr<PeerConnectionInterface::IceServer>>& ice_servers) override {
// 1. 创建 PeerConnection 对象
PeerConnection* pc = new PeerConnection(options, config, ice_servers);
// 2. 初始化内部状态
pc->Initialize();
// 3. 返回封装对象
return rtc::scoped_refptr<RTCPeerConnectionInterface>(pc);
}
// 创建 DataChannel
rtc::scoped_refptr<RTCDataChannelInterface> CreateDataChannel(
const std::string& label, const DataChannelInterface::Init& config) override {
// 实现 DataChannel 创建逻辑
// ...
}
};
scoped_refptr 确保对象生命周期安全PeerConnectionFactoryInterface 接口应用层 (JavaScript) -> API 层 (WebRTC API) -> 核心引擎层 (C++)
1. new RTCPeerConnection()
2. 调用 PeerConnectionFactory::CreatePeerConnection()
3. 创建 PeerConnection 对象
4. 返回 PeerConnection 实例
5. 返回 RTCPeerConnection 实例
6. getUserMedia()
7. 调用 MediaStreamInterface 实现
8. 获取媒体设备
9. 返回媒体流
10. 返回 MediaStream 对象
11. createOffer()
12. 调用 PeerConnection::CreateOffer()
13. 生成 SDP Offer
14. 返回 SDP Offer
15. 返回 Offer SDP
16. setLocalDescription()
17. 调用 PeerConnection::SetLocalDescription()
18. 更新连接状态
19. 确认设置
20. 确认设置
21. addTrack()
22. 调用 PeerConnection::AddTrack()
23. 添加媒体轨道
24. 确认添加
25. 确认添加
26. onicecandidate 事件处理
27. 监听 ICE 候选
28. 收集 ICE 候选
29. 触发 onicecandidate 事件
JavaScript 应用层代码:
const pc = new RTCPeerConnection({
iceServers: [{ urls: "stun:stun.l.google.com:19302" }]
});
API 层工作流程:
new RTCPeerConnection()PeerConnectionFactory::CreatePeerConnection()PeerConnection 对象RTCPeerConnectionInterface 对象关键源码:
// pc/peerconnectionfactory.cc
rtc::scoped_refptr<RTCPeerConnectionInterface>
PeerConnectionFactory::CreatePeerConnection(
const PeerConnectionInterface::Options& options,
const PeerConnectionInterface::RTCConfiguration& config,
const std::vector<rtc::scoped_refptr<PeerConnectionInterface::IceServer>>& ice_servers) {
// 创建 PeerConnection 对象
PeerConnection* pc = new PeerConnection(options, config, ice_servers);
// 初始化内部状态
pc->Initialize();
// 返回封装对象
return rtc::scoped_refptr<RTCPeerConnectionInterface>(pc);
}
JavaScript 应用层代码:
const stream = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
API 层工作流程:
getUserMedia()MediaStreamInterface 实现关键源码:
// api/mediastreaminterface.h
class MediaStreamInterface {
public:
static rtc::scoped_refptr<MediaStreamInterface> CreateLocalMediaStream(const std::string& label);
};
// 实现部分
rtc::scoped_refptr<MediaStreamInterface>
MediaStreamInterface::CreateLocalMediaStream(const std::string& label) {
return CreateLocalMediaStreamInternal(label);
}
JavaScript 应用层代码:
const offer = await pc.createOffer();
await pc.setLocalDescription(offer);
signalingServer.send({ type: "offer", sdp: offer.sdp });
API 层工作流程:
createOffer()PeerConnection::CreateOffer()CreateOfferInternal() 生成 SDP OfferSetLocalDescriptionInternal() 设置本地描述关键源码:
// pc/peerconnectioninterface.cc
void PeerConnection::CreateOffer(CreateSessionDescriptionObserver* observer,
const RTCOfferOptions* options) {
SessionDescriptionInterface* offer = CreateOfferInternal(options);
if (offer) SetLocalDescriptionInternal(offer);
if (observer) observer->OnSuccess(offer);
}
SessionDescriptionInterface* PeerConnection::CreateOfferInternal(const RTCOfferOptions* options) {
// 实际 SDP 生成逻辑
return new SessionDescription(offer_sdp);
}
void PeerConnection::SetLocalDescriptionInternal(SessionDescriptionInterface* desc) {
local_desc_ = desc;
GenerateIceCandidates();
core_engine_->SetLocalDescription(desc);
}
JavaScript 应用层代码:
pc.onicecandidate = event => {
if (event.candidate) {
signalingServer.send({ type: "candidate", candidate: event.candidate });
}
};
API 层工作流程:
onicecandidate 事件onicecandidate 事件通知应用层关键源码:
// pc/peerconnectioninterface.cc
void PeerConnection::GenerateIceCandidates() {
std::vector<IceCandidateInterface*> candidates;
core_engine_->GetIceCandidates(&candidates);
for (auto& candidate : candidates) {
OnIceCandidate(candidate);
}
}
void PeerConnection::OnIceCandidate(const IceCandidateInterface* candidate) {
if (ice_candidate_observer_) {
ice_candidate_observer_->OnIceCandidate(candidate);
}
}
信令模块是 WebRTC 核心引擎层的关键组成部分,负责处理 WebRTC 会话的建立、协商和管理。信令模块的主要作用是交换 SDP(Session Description Protocol)描述和 ICE 候选地址,以建立 P2P 连接。
WebRTC 本身不提供信令机制,需要开发者实现自己的信令服务器。虽然 WebRTC核心源码本身不包含完整的信令服务器实现,但这是设计层面的刻意选择:
实际开发:信令服务器需要开发者自行实现(或使用开源方案如 Janus/Mediasoup/OpenVidu),核心职责是转发 SDP、ICE 候选者、房间控制指令等。
信令服务器用于交换以下关键信息:
信令机制的核心原理
WebRTC 的信令机制是'桥梁',连接两个对等端。它不负责媒体传输,只负责交换建立连接所需的信息。信令机制包括以下关键步骤:
信令模块的作用:
信令模块的核心代码位于 webrtc/pc 和 webrtc/api 目录下,以下是关键文件及其作用:
peer_connection.h 和 peer_connection_impl.h// webrtc/pc/peer_connection.h
class RTCPeerConnection {
public:
static std::unique_ptr<RTCPeerConnection> Create(const PeerConnectionInterface::Options& options);
virtual void CreateOffer(CreateSessionDescriptionObserver* observer,
const RTCOfferAnswerOptions* options = nullptr) = 0;
virtual void CreateAnswer(CreateSessionDescriptionObserver* observer,
const RTCOfferAnswerOptions* options = nullptr) = 0;
virtual void SetLocalDescription(SetSessionDescriptionObserver* observer,
SessionDescriptionInterface* desc) = 0;
virtual void SetRemoteDescription(SetSessionDescriptionObserver* observer,
SessionDescriptionInterface* desc) = 0;
virtual void AddIceCandidate(const IceCandidateInterface* candidate) = 0;
virtual void GetIceCandidates(std::vector<IceCandidateInterface*>* candidates) = 0;
= ;
};
作用:定义 RTCPeerConnection 接口,实现信令交互的核心功能,包括创建 offer/answer、设置本地/远程描述、添加 ICE 候选等。
session_description.h 和 session_description_impl.h// webrtc/pc/session_description.h
class SessionDescriptionInterface {
public:
virtual SessionDescriptionType type() const = 0;
virtual const std::string& ToString() const = 0;
virtual const std::vector<MediaContentDescriptionInterface*>& contents() const = 0;
};
作用:定义 SDP 会话描述的接口,用于表示 offer 和 answer 的媒体信息,包括编解码器、分辨率、带宽等参数。
ice_candidate.h 和 ice_candidate_impl.h// webrtc/pc/ice_candidate.h
class IceCandidateInterface {
public:
virtual const std::string& candidate() const = 0;
virtual const std::string& sdp_mid() const = 0;
virtual int sdp_mline_index() const = 0;
};
作用:定义 ICE 候选的接口,用于表示 NAT 穿透过程中收集的候选地址,包括 Host 候选、Server Reflexive 候选和 Relay 候选。
signaling_channel.h 和 signaling_channel_impl.h// webrtc/pc/signaling_channel.h
class SignalingChannel {
public:
virtual ~SignalingChannel() {}
virtual void SendOffer(const SessionDescriptionInterface* offer) = 0;
virtual void SendAnswer(const SessionDescriptionInterface* answer) = 0;
virtual void SendLocalDescription(const SessionDescriptionInterface* desc) = 0;
virtual void SendIceCandidate(const IceCandidateInterface* candidate) = 0;
virtual void SetMessageHandler(std::function<void(const SignalingMessage&)> handler) = 0;
};
作用:定义信令通道的接口,用于实现具体的信令传输方式(如 WebSocket、MQTT 等),将 SDP 和 ICE 候选通过信令服务器发送给对端。
// webrtc/pc/peer_connection_impl.cc
class RTCPeerConnectionImpl : public RTCPeerConnection {
public:
RTCPeerConnectionImpl(const PeerConnectionInterface::Options& options)
: options_(options), signaling_thread_(nullptr), transport_(nullptr), media_engine_(nullptr) {
signaling_thread_ = new rtc::Thread("SignalingThread");
signaling_thread_->Start();
transport_ = new Transport();
transport_->Init();
media_engine_ = new MediaEngine();
media_engine_->Init();
}
void CreateOffer(CreateSessionDescriptionObserver* observer,
const RTCOfferAnswerOptions* options) override {
SessionDescriptionInterface* offer = media_engine_->CreateOffer(options);
local_description_ = offer;
if (signaling_channel_) signaling_channel_->SendOffer(offer);
observer->OnSuccess(offer);
}
void CreateAnswer(CreateSessionDescriptionObserver* observer,
const RTCOfferAnswerOptions* options) override {
SessionDescriptionInterface* answer = media_engine_->CreateAnswer(options);
local_description_ = answer;
if (signaling_channel_) signaling_channel_->(answer);
observer->(answer);
}
{
local_description_ = desc;
(signaling_channel_) signaling_channel_->(desc);
observer->();
}
{
remote_description_ = desc;
media_engine_->(desc);
transport_->(desc);
observer->();
}
{
ice_candidates_.(candidate);
(signaling_channel_) signaling_channel_->(candidate);
}
{
ice_connection_state_ = state;
(ice_connection_state_observer_) {
ice_connection_state_observer_->(state);
}
}
:
PeerConnectionInterface::Options options_;
rtc::Thread* signaling_thread_;
Transport* transport_;
MediaEngine* media_engine_;
SessionDescriptionInterface* local_description_;
SessionDescriptionInterface* remote_description_;
std::vector<IceCandidateInterface*> ice_candidates_;
IceConnectionState ice_connection_state_;
IceConnectionStateObserver* ice_connection_state_observer_;
SignalingChannel* signaling_channel_;
};
RTCPeerConnectionImpl 是 RTCPeerConnection 的实现类CreateOffer() 和 CreateAnswer() 生成 SDP 描述SetLocalDescription() 和 SetRemoteDescription() 设置本地和远程描述AddIceCandidate() 添加 ICE 候选OnIceConnectionStateChange() 处理 ICE 连接状态变化// webrtc/pc/signaling_channel_impl.h
class WebSocketSignalingChannel : public SignalingChannel {
public:
WebSocketSignalingChannel(const std::string& url) : url_(url), socket_(nullptr) {
Connect();
}
void SendOffer(const SessionDescriptionInterface* offer) override {
SignalingMessage message;
message.type = "sdp_offer";
message.data = offer->ToString();
Send(message);
}
void SendAnswer(const SessionDescriptionInterface* answer) override {
SignalingMessage message;
message.type = "sdp_answer";
message.data = answer->ToString();
Send(message);
}
void SendLocalDescription(const SessionDescriptionInterface* desc) override {
SignalingMessage message;
message.type = "sdp_local";
message.data = desc->ToString();
Send(message);
}
void SendIceCandidate(const IceCandidateInterface* candidate) override {
SignalingMessage message;
message.type = "ice_candidate";
message.data = candidate->candidate();
message.sdp_mid = candidate->();
message.sdp_mline_index = candidate->();
(message);
}
{
message_handler_ = handler;
}
:
{
socket_ = (url_);
socket_->([]( std::string& message) {
SignalingMessage msg;
(message, &msg);
(message_handler_) (msg);
});
}
{
std::string json = (message);
socket_->(json);
}
std::string url_;
WebSocket* socket_;
std::function<( SignalingMessage&)> message_handler_;
};
SignalingChannel 是信令通道的接口类WebSocketSignalingChannel 是 WebSocket 信令通道的实现类SendOffer() 和 SendAnswer() 发送 SDP offer 和 answerSendIceCandidate() 发送 ICE 候选SetMessageHandler() 设置消息处理回调参与者 A -> 信令模块 -> 信令服务器 -> 信令模块 -> 参与者 B
1. 创建 RTCPeerConnection
2. 采集媒体流
3. CreateOffer -> 生成 SDP offer
4. 发送 SDP offer -> 转发 SDP offer
5. 创建 RTCPeerConnection
6. 采集媒体流
7. CreateAnswer -> 生成 SDP answer
8. 发送 SDP answer -> 转发 SDP answer
9. SetRemoteDescription -> 配置媒体引擎
10. AddIceCandidate -> 收集 ICE 候选
11. 通过 STUN 获取公网 IP -> 返回 ICE 候选
12. 发送 ICE 候选 -> 转发 ICE 候选
13. AddIceCandidate -> 设置 ICE 候选
14. 尝试建立 P2P 连接 -> 连接成功
15. 通知连接状态 -> 通知连接状态
16. 接收媒体流 -> 接收媒体流
SDP 是 WebRTC 信令的核心,用于描述媒体会话的参数,包括:
SDP 格式示例:
v=0 o=- 123456 1 IN IP4 127.0.0.1 s=- t=0 0 m=audio 9 UDP/TLS/RTP/SAVPF 111 103 104 c=IN IP4 192.168.1.100 a=rtcp:9 IN IP4 192.168.1.100 a=rtpmap:111 opus/48000/2 a=fmtp:111 minptime=10;useinbandfec=1 a=sendrecv
ICE 候选是 NAT 穿透的关键,包括:
ICE 候选格式示例:
candidate:1 1 udp 2130706431 192.168.1.100 54321 typ host
candidate:2 1 udp 1686052607 203.0.113.1 54321 typ srflx raddr 192.168.1.100 rport 54321
candidate:3 1 udp 1500000000 198.51.100.1 54321 typ relay raddr 192.168.1.100 rport 54321
WebRTC 没有定义具体的信令协议,开发者可以使用各种方式,如:
信令消息格式示例:
{"type":"sdp_offer","data":"v=0\r\no=- 123456 1 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 111 103 104\r\nc=IN IP4 192.168.1.100\r\na=rtcp:9 IN IP4 192.168.1.100\r\na=rtpmap:111 opus/48000/2\r\na=fmtp:111 minptime=10;useinbandfec=1\r\na=sendrecv\r\n"}
pc.oniceconnectionstatechange = () => {
if (pc.iceconnectionstate() == "disconnected") {
restartIce();
}
};
function restartIce() {
const offer = pc.createoffer();
pc.setlocaldescription(offer);
signaling_channel_->sendoffer(offer);
}
关键点:
pc.addeventlistener("negotiationneeded", () => {
const transceiver = pc.gettransceivers()[0];
transceiver.setcodecpreferences(filtercodecs("vp9"));
});
关键点:
更高效的信令协议
WebRTC 信令模块将采用更高效的信令协议:
AI 增强的信令处理
WebRTC 信令模块将集成 AI 技术,实现更智能的信令处理:
信令与边缘计算结合
WebRTC 信令模块将与边缘计算结合,实现更高效的信令处理:

微信公众号「极客日志」,在微信中扫描左侧二维码关注。展示文案:极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具,Base64 字符串编码/解码在线工具,online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具,Base64 文件转换器在线工具,online
将 Markdown(GFM)转为 HTML 片段,浏览器内 marked 解析;与 HTML转Markdown 互为补充。 在线工具,Markdown转HTML在线工具,online
将 HTML 片段转为 GitHub Flavored Markdown,支持标题、列表、链接、代码块与表格等;浏览器内处理,可链接预填。 在线工具,HTML转Markdown在线工具,online
通过删除不必要的空白来缩小和压缩JSON。 在线工具,JSON 压缩在线工具,online
将JSON字符串修饰为友好的可读格式。 在线工具,JSON美化和格式化在线工具,online