webrtc入门：8.coturn流程

已于 2022-05-13 13:32:43 修改
阅读量4.6k 收藏 13
点赞数 1
分类专栏： webrtc入门 文章标签： webrtc 服务器 网络
于 2022-05-13 13:29:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40425640/article/details/124748151
版权

对于局域网中的webrtc是不需要coturn，因为他们自己进行视频流的传输，但通常的应用场景，在同一个局域网下概率是比较低的，因此我们需要把流推到服务器上，另外一端在从服务器把流拉下来。coturn做为turnserver做的是这一部分的工作。当然coturn也可以作为 stun服务器，这篇文章先不讲，只讲turnserver这部分的内容。

turnserver的原理是根据webrtc的协议而定的，最主要的功能就是转发webrtc上的数据流，在转发数据流中，最关键的是两样，一个是创建流端口连接，一个是匹配端口。

当webrtc的客户端配置上了ICE_SERVER 以后，客户端会去ICE_SERVER 请求一个端口用来传递数据流，这就是所谓的ice，在互换了ice以后，会选出一个通路来匹配到另一端的通路，数据在服务端中进行转发传递。

这也就是最重要的两个环节，创建流通路和匹配通道。

1.创建流通路

webrtc的客户端向服务器发起连接，通过命令告诉服务器他需要的东西。

static int handle_turn_command(turn_turnserver *server, ts_ur_super_session *ss, ioa_net_data *in_buffer, ioa_network_buffer_handle nbh, int *resp_constructed, int can_resume)
{

	...

		if (!err_code && !(*resp_constructed) && !no_response) {

			switch (method){

			case STUN_METHOD_ALLOCATE:

			{
				handle_turn_allocate(server, ss, &tid, resp_constructed, &err_code, &reason,
							unknown_attrs, &ua_num, in_buffer, nbh);

				if(server->verbose) {
				  log_method(ss, "ALLOCATE", err_code, reason);
				}

				break;
			}

			...
	return 0;
}

在对 turn 的命令进行处理时，STUN_METHOD_ALLOCATE告诉服务器，需要分配一个新的通道。

static int handle_turn_allocate(turn_turnserver *server,
				ts_ur_super_session *ss, stun_tid *tid, int *resp_constructed,
				int *err_code, 	const u08bits **reason, u16bits *unknown_attrs, u16bits *ua_num,
				ioa_net_data *in_buffer, ioa_network_buffer_handle nbh) {


	...

				if(!(*err_code)) {
					if(!af4 && !af6) {
						int af4res = create_relay_connection(server, ss, lifetime,
							STUN_ATTRIBUTE_REQUESTED_ADDRESS_FAMILY_VALUE_DEFAULT, transport,
							even_port, in_reservation_token, &out_reservation_token,
							err_code, reason,
							tcp_peer_accept_connection);
						if(af4res<0) {
							set_relay_session_failure(alloc,AF_INET);
							if(!(*err_code)) {
								*err_code = 437;
							}
						}
					} else if(!af4 && af6) {
						int af6res = create_relay_connection(server, ss, lifetime,
							af6, transport,
							even_port, in_reservation_token, &out_reservation_token,
							err_code, reason,
							tcp_peer_accept_connection);
						if(af6res<0) {
							set_relay_session_failure(alloc,AF_INET6);
							if(!(*err_code)) {
								*err_code = 437;
							}
						}
					} else if(af4 && !af6) {
						int af4res = create_relay_connection(server, ss, lifetime,
							af4, transport,
							even_port, in_reservation_token, &out_reservation_token,
							err_code, reason,
							tcp_peer_accept_connection);
						if(af4res<0) {
							set_relay_session_failure(alloc,AF_INET);
							if(!(*err_code)) {
								*err_code = 437;
							}
						}
					} else {
						const u08bits *reason4 = NULL;
						const u08bits *reason6 = NULL;
						{
							int af4res = create_relay_connection(server, ss, lifetime,
									af4, transport,
									even_port, in_reservation_token, &out_reservation_token,
									&err_code4, &reason4,
									tcp_peer_accept_connection);
							if(af4res<0) {
								set_relay_session_failure(alloc,AF_INET);
								if(!err_code4) {
									err_code4 = 440;
								}
							}
						}
						{
							int af6res = create_relay_connection(server, ss, lifetime,
												af6, transport,
												even_port, in_reservation_token, &out_reservation_token,
												&err_code6, &reason6,
												tcp_peer_accept_connection);
							if(af6res<0) {
								set_relay_session_failure(alloc,AF_INET6);
								if(!err_code6) {
									err_code6 = 440;
								}
							}
						}

						if(err_code4 && err_code6) {
							if(reason4) {
								*err_code = err_code4;
								*reason = reason4;
							} else if(reason6) {
								*err_code = err_code6;
								*reason = reason6;
							} else {
								*err_code = err_code4;
							}
						}
					}
				}

				...

	return 0;
}

create_relay_connection 用来创建 relay的连接，具体在看看create_relay_connection 的内容。

static int create_relay_connection(turn_turnserver* server,
				   ts_ur_super_session *ss, u32bits lifetime,
				   int address_family, u08bits transport,
				   int even_port, u64bits in_reservation_token, u64bits *out_reservation_token,
				   int *err_code, const u08bits **reason,
				   accept_cb acb) {

	... else {

			newelem = get_relay_session_ss(ss,get_family(address_family));

			IOA_CLOSE_SOCKET(newelem->s);

			ns_bzero(newelem, sizeof(relay_endpoint_session));
			newelem->s = NULL;

			int res = create_relay_ioa_sockets(server->e,
							ss->client_socket,
							address_family, transport,
							even_port, &(newelem->s), &rtcp_s, out_reservation_token,
							err_code, reason, acb, ss);
			if (res < 0) {
				if(!(*err_code))
					*err_code = 508;
				if(!(*reason))
					*reason = (const u08bits *)"Cannot create socket";
				IOA_CLOSE_SOCKET(newelem->s);
				IOA_CLOSE_SOCKET(rtcp_s);
				return -1;
			}
		}

		...
		
		/* RFC6156: do not use DF when IPv6 is involved: */
		if((get_ioa_socket_address_family(newelem->s) == AF_INET6) ||
		   (get_ioa_socket_address_family(ss->client_socket) == AF_INET6))
			set_do_not_use_df(newelem->s);

		if(get_ioa_socket_type(newelem->s) != TCP_SOCKET) {
			if(register_callback_on_ioa_socket(server->e, newelem->s, IOA_EV_READ,peer_input_handler, ss, 0)<0) {
				return -1;
			}
		}

	return 0;
}

关键的代码在 create_relay_ioa_sockets 下，现在sockerts的字眼已经出现了，建立完成以后，设置了peer_input_handler的匹配回调接口。

int create_relay_ioa_sockets(ioa_engine_handle e,
				ioa_socket_handle client_s,
				int address_family, u08bits transport,
				int even_port, ioa_socket_handle *rtp_s,
				ioa_socket_handle *rtcp_s, uint64_t *out_reservation_token,
				int *err_code, const u08bits **reason,
				accept_cb acb, void *acbarg)
{

	...

	for (iip = 0; iip < e->relays_number; ++iip) {

		...
		addr_cpy(&rtcp_local_addr, &relay_addr);

		int i = 0;
		int port = 0;
		ioa_addr local_addr;
		addr_cpy(&local_addr, &relay_addr);
		for (i = 0; i < 0xFFFF; i++) {
			port = 0;
			rtcp_port = -1;
			if (even_port < 0) {
				port = turnipports_allocate(tp, transport, &relay_addr);
			} else {

				port = turnipports_allocate_even(tp, &relay_addr, even_port, out_reservation_token);
				if (port >= 0 && even_port > 0) {

					IOA_CLOSE_SOCKET(*rtcp_s);
					*rtcp_s = create_unbound_relay_ioa_socket(e, relay_addr.ss.sa_family, UDP_SOCKET, RELAY_RTCP_SOCKET);
					if (*rtcp_s == NULL) {
						perror("socket");
						IOA_CLOSE_SOCKET(*rtp_s);
						addr_set_port(&local_addr, port);
						turnipports_release(tp, transport, &local_addr);
						rtcp_port = port + 1;
						addr_set_port(&rtcp_local_addr, rtcp_port);
						turnipports_release(tp, transport, &rtcp_local_addr);
						return -1;
					}
					sock_bind_to_device((*rtcp_s)->fd, (unsigned char*)e->relay_ifname);

					rtcp_port = port + 1;
					addr_set_port(&rtcp_local_addr, rtcp_port);
					if (bind_ioa_socket(*rtcp_s, &rtcp_local_addr,
						(transport == STUN_ATTRIBUTE_TRANSPORT_TCP_VALUE)) < 0) {
						addr_set_port(&local_addr, port);
						turnipports_release(tp, transport, &local_addr);
						turnipports_release(tp, transport, &rtcp_local_addr);
						rtcp_port = -1;
						IOA_CLOSE_SOCKET(*rtcp_s);
						continue;
					}
				}
			}
			if (port < 0) {
				IOA_CLOSE_SOCKET(*rtp_s);
				if (rtcp_s)
					IOA_CLOSE_SOCKET(*rtcp_s);
				rtcp_port = -1;
				break;
			} else {

				IOA_CLOSE_SOCKET(*rtp_s);

				*rtp_s = create_unbound_relay_ioa_socket(e, relay_addr.ss.sa_family,
										(transport == STUN_ATTRIBUTE_TRANSPORT_TCP_VALUE) ? TCP_SOCKET : UDP_SOCKET,
										RELAY_SOCKET);
				if (*rtp_s == NULL) {
					int rtcp_bound = 0;
					if (rtcp_s && *rtcp_s) {
						rtcp_bound = (*rtcp_s)->bound;
						IOA_CLOSE_SOCKET(*rtcp_s);
					}
					addr_set_port(&local_addr, port);
					turnipports_release(tp, transport, &local_addr);
					if (rtcp_port >= 0 && !rtcp_bound) {
						addr_set_port(&rtcp_local_addr, rtcp_port);
						turnipports_release(tp, transport, &rtcp_local_addr);
					}
					perror("socket");
					return -1;
				}

				sock_bind_to_device((*rtp_s)->fd, (unsigned char*)e->relay_ifname);

				addr_set_port(&local_addr, port);
				if (bind_ioa_socket(*rtp_s, &local_addr,
					(transport == STUN_ATTRIBUTE_TRANSPORT_TCP_VALUE)) >= 0) {
					break;
				} else {
					IOA_CLOSE_SOCKET(*rtp_s);
					int rtcp_bound = 0;
					if (rtcp_s && *rtcp_s) {
						rtcp_bound = (*rtcp_s)->bound;
						IOA_CLOSE_SOCKET(*rtcp_s);
					}
					addr_set_port(&local_addr, port);
					turnipports_release(tp, transport, &local_addr);
					if (rtcp_port >= 0 && !rtcp_bound) {
						addr_set_port(&rtcp_local_addr, rtcp_port);
						turnipports_release(tp, transport, &rtcp_local_addr);
					}
					rtcp_port = -1;
				}
			}
		}


	}

	if (!(*rtp_s)) {
		TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "%s: no available ports 3\n", __FUNCTION__);
		IOA_CLOSE_SOCKET(*rtp_s);
		if (rtcp_s)
			IOA_CLOSE_SOCKET(*rtcp_s);
		return -1;
	}

	set_accept_cb(*rtp_s, acb, acbarg);

	if (rtcp_s && *rtcp_s && out_reservation_token && *out_reservation_token) {
		if (rtcp_map_put(e->map_rtcp, *out_reservation_token, *rtcp_s) < 0) {
			TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "%s: cannot update RTCP map\n", __FUNCTION__);
			IOA_CLOSE_SOCKET(*rtp_s);
			if (rtcp_s)
				IOA_CLOSE_SOCKET(*rtcp_s);
			return -1;
		}
	}
	...

	return 0;
}

这样就创建了一个通道，打印的日志如下，

1584: IPv4. Local relay addr: 117.25.xxx.xxx:64425

如果把这个数据给到webrtc的客户端呢？也是通过stun的协议，发到请求的客户端上。

2.匹配通道

两个客户端都建立了连接，在交换信息的时候，我们需要知道谁跟谁是配对的，这样我们可以把流发到对方上，问题还是的 从handle_turn_command看起，handle_turn_command接收到了STUN_METHOD_CHANNEL_BIND 绑定通道的命令，这个命令下会获取匹配的信息，下面是具体的流程分析。

static int handle_turn_command(turn_turnserver *server, ts_ur_super_session *ss, ioa_net_data *in_buffer, ioa_network_buffer_handle nbh, int *resp_constructed, int can_resume)
{

	...

			case STUN_METHOD_CHANNEL_BIND:

				handle_turn_channel_bind(server, ss, &tid, resp_constructed, &err_code, &reason,
								unknown_attrs, &ua_num, in_buffer, nbh);

				if(server->verbose) {
				  log_method(ss, "CHANNEL_BIND", err_code, reason);
				}
				break;

			case STUN_METHOD_CREATE_PERMISSION:

				handle_turn_create_permission(server, ss, &tid, resp_constructed, &err_code, &reason,
								unknown_attrs, &ua_num, in_buffer, nbh);

				if(server->verbose) {
				  log_method(ss, "CREATE_PERMISSION", err_code, reason);
				}
				break;

			...

	return 0;
}

接着继续看看handle_turn_channel_bind后面做了什么 事情。

static int handle_turn_channel_bind(turn_turnserver *server,
				    ts_ur_super_session *ss, stun_tid *tid, int *resp_constructed,
				    int *err_code, const u08bits **reason, u16bits *unknown_attrs, u16bits *ua_num,
				    ioa_net_data *in_buffer, ioa_network_buffer_handle nbh) {

	...
			case STUN_ATTRIBUTE_XOR_PEER_ADDRESS:
			  {
				stun_attr_get_addr_str(ioa_network_buffer_data(in_buffer->nbh), 
						       ioa_network_buffer_get_size(in_buffer->nbh), 
						       sar, &peer_addr,
						       NULL);

				if(!get_relay_socket(a,peer_addr.ss.sa_family)) {
					*err_code = 443;
					*reason = (const u08bits *)"Peer Address Family Mismatch (3)";
				}

				if(addr_get_port(&peer_addr) < 1) {
					*err_code = 400;
					*reason = (const u08bits *)"Empty port number in channel bind request";
				} else {
					addr_found = 1;
				}

				break;
			  }
			default:
				if(attr_type>=0x0000 && attr_type<=0x7FFF)
					unknown_attrs[(*ua_num)++] = nswap16(attr_type);
			};
			sar = stun_attr_get_next_str(ioa_network_buffer_data(in_buffer->nbh), 
						     ioa_network_buffer_get_size(in_buffer->nbh), 
						     sar);
		}

		...

				chn = allocation_get_ch_info_by_peer_addr(a, &peer_addr);
				if(chn) {
					*err_code = 400;
					*reason = (const u08bits *)"You cannot use the same peer with different channel number";
				} else {
					if(!good_peer_addr(server,ss->realm_options.name,&peer_addr)) {
						*err_code = 403;
						*reason = (const u08bits *) "Forbidden IP";
					} else {
						chn = allocation_get_new_ch_info(a, chnum, &peer_addr);
						if (!chn) {
							*err_code = 500;
							*reason = (const u08bits *) "Cannot find channel data";
						} else {
							tinfo = (turn_permission_info*) (chn->owner);
							if (!tinfo) {
								*err_code = 500;
								*reason
									= (const u08bits *) "Wrong turn permission info";
							}
						}
					}
				}
			}
			
...

	return 0;
}

通过STUN_ATTRIBUTE_XOR_PEER_ADDRESS命令，获取到peer_addr 的地址，紧接着good_peer_addr看看是不是被屏蔽的地址，而后把配对的地址放到map中。

ch_info* allocation_get_new_ch_info(allocation* a, u16bits chnum, ioa_addr* peer_addr)
{

	turn_permission_info* tinfo = get_from_turn_permission_hashtable(&(a->addr_to_perm), peer_addr);

	if (!tinfo)
		tinfo = allocation_add_permission(a, peer_addr);

	ch_info* chn = ch_map_get(&(a->chns), chnum, 1);

	chn->allocated = 1;
	chn->chnum = chnum;
	chn->port = addr_get_port(peer_addr);
	addr_cpy(&(chn->peer_addr), peer_addr);
	chn->owner = tinfo;

	lm_map_put(&(tinfo->chns), (ur_map_key_type) addr_get_port(peer_addr), (ur_map_value_type) chn);

	return chn;
}

用lm_map_put把peer_addr地址放到map中去。

在前面打通了 客户到服务器的通道，在通道获取到客户端的数据时，通过read_client_connection获取到客户端的数据，并转发到匹配的端上。

static int read_client_connection(turn_turnserver *server,
				  	  	  	  	  ts_ur_super_session *ss, ioa_net_data *in_buffer,
				  	  	  	  	  int can_resume, int count_usage) {

	...
		if(blen<=orig_blen) {
			ioa_network_buffer_set_size(in_buffer->nbh,blen);
			rc = write_to_peerchannel(ss, chnum, in_buffer);
		}

		if (eve(server->verbose)) {
			TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "%s: wrote to peer %d bytes\n",
					__FUNCTION__, (int) rc);
		}

		FUNCEND;
		return 0;

	} ...
	return -1;
}

write_to_peerchannel负责把数据转发到匹配的通道上，跟进去可以看到。

static int write_to_peerchannel(ts_ur_super_session* ss, u16bits chnum, ioa_net_data *in_buffer) {

	int rc = 0;

	if (ss && (in_buffer->recv_ttl!=0)) {

		allocation* a = get_allocation_ss(ss);

		if (is_allocation_valid(a)) {

			ch_info* chn = allocation_get_ch_info(a, chnum);

			if (!chn)
				return -1;

			/* Channel packets are always sent with DF=0: */
			set_df_on_ioa_socket(get_relay_socket_ss(ss, chn->peer_addr.ss.sa_family), 0);

			ioa_network_buffer_handle nbh = in_buffer->nbh;

			ioa_network_buffer_add_offset_size(in_buffer->nbh, STUN_CHANNEL_HEADER_LENGTH, 0, ioa_network_buffer_get_size(in_buffer->nbh)-STUN_CHANNEL_HEADER_LENGTH);

			ioa_network_buffer_header_init(nbh);

			rc = send_data_from_ioa_socket_nbh(get_relay_socket_ss(ss, chn->peer_addr.ss.sa_family), &(chn->peer_addr), nbh, in_buffer->recv_ttl-1, in_buffer->recv_tos, NULL);
			in_buffer->nbh = NULL;
		}
	}

	return rc;
}

allocation_get_ch_info 是用来获取匹配地址的，之前我们把它放到map下了。

ch_info* allocation_get_ch_info(allocation* a, u16bits chnum) {
	return ch_map_get(&(a->chns), chnum, 0);
}

通过send_data_from_ioa_socket_nbh 把数据发到指定的地址上。

int send_data_from_ioa_socket_nbh(ioa_socket_handle s, ioa_addr* dest_addr,
				ioa_network_buffer_handle nbh,
				int ttl, int tos, int *skip)
{
	...
						if (s->connected && !(s->parent_s)) {
							dest_addr = NULL; /* ignore dest_addr */
						} else if (!dest_addr) {
							dest_addr = &(s->remote_addr);
						}

						ret = udp_send(s,
									dest_addr,
									(s08bits*) ioa_network_buffer_data(nbh),ioa_network_buffer_get_size(nbh));
	...
}

这样通过udp_send 把数据发出去。

到这里，两个重大的 问题，都得到了答案。

连通了以后，服务器不断的报告数据的信息：

59025: session 015000000000000001: usage: realm=<nort.gov>, username=<xxx>, rp=1020, rb=903980, sp=1028, sb=907260
59025: session 012000000000000004: usage: realm=<nort.gov>, username=<xxx>, rp=1027, rb=905188, sp=1021, sb=904052
59027: session 015000000000000001: usage: realm=<nort.gov>, username=<xxx>, rp=1020, rb=898622, sp=1028, sb=906288
59027: session 012000000000000004: usage: realm=<nort.gov>, username=<xxx>, rp=1028, rb=906288, sp=1020, sb=898622
go2coding
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
WebRTC1.0：浏览器间实时通讯.pdf
11-08
本文是WebRTC工作组最新一次会议后的候选推荐标准，基于WebIDL定义了一组ECMAScript API，允许在实现了相关实时协议的浏览器或设备之间发送和接收媒体内容。同时也是对WebRTC的一个全面介绍，包括WebRTC中的各个术语，独有的概念，API的使用规范，详细的算法流程和一些注意点，并且对涉及的数据结构及其属性进行了剖析。在特定的使用场景下，草案的作者们还附上了示例代码。
webrtc-adapter:用于WebRTC的Commonjs adapter.js浏览器兼容性填充程序
05-03
webrtc适配器用于WebRTC的Commonjs adapter.js浏览器兼容性填充程序关于WebRTC适配器提供了更符合标准的浏览器RTC对象版本，供在使用WebRTC的浏览器项目中使用。 它是为或 “编辑项目，使用节点样式require的语法，...
公司内网虚拟机中穿透服务器Coturn的搭建
拉你手跟我走的专栏
01-25 1720
以下进程为服务方式启动，这种进程数有点多，以命令行启动只有4条，这不重要。以服务形式启动（具体如何形成的服务，不清楚、不知道，同事之前搞的）其实就是查看linux中服务的日志，coturn访问时报错要用到。Coturn集成了stun+turn协议。
使用Docker运行coturn服务实现RTCPeerConnection的内网穿透
最新发布
饶荣的博客
05-20 531
2.从源码找到turndb/schema.sql脚本创建数据库，使用turndb/testsqldbsetup.sql脚本初始化一些数据，不需要的数据可以删除，比如默认的用户信息。容器使用宿主机的网络，默认端口号3478/TCP，以及上述文件中的UDP端口，将turnserver.conf文件映射到容器内，-a -f 等参数可以进入容器查看帮助信息。完整文件很长，这里只列出部分内容，主要是设置端口范围，用户密码使用的mysql数据库连接信息，要求身份验证等。1.拉取coturn镜像。
WebRTC 网络中继 Coturn 服务安装及部署
KeiSoft
06-01 3528
本文主要介绍Coturn 在 Linux、Windows 系统下部署的步骤。
webrtc入门系列（三）云服务器coturn环境搭建
一只海星的主页
04-13 2604
这几天零碎的搜索，已经大概摸清楚了ipc想要接入webrtc的一些流程，其中打洞服务器必不可少，我们选择coturn来做为服务器。好早就想云服务器切换成Ubuntu，乘机一起迁移切换了系统，忙了一个周末，还触发了腾讯云的bug，补偿了50代金券。
coturn穿透服务器安装部署
★ James Liu @ CSDN
06-27 5593
因为部署Janus的需要，把安装整个coturn服务器的过程记录下来备忘。 1、环境 服务器：阿里云ECS 系统：ubuntu16.04，采用root账号登录。 2、下载coturn版本 下载coturn官方版本：https://github.com/coturn/coturn https://github.com/coturn/coturn/tags选择合适的TAG版本下载。 我选择的是4.5.2版本。 3、安装依赖 先进行解压，tar -zxvf turnserver-4.5.2.
coturn服务器部署
w13511069150的博客
05-22 9897
一、coturn coturn 服务器完整的实现了 STUN/TURN/ICE 协议，支持 P2P 穿透防火墙。主要用于 webrtc 等点对点视频音频通话。 coturn 支持 tcp, udp, tls, dtls 连接；支持 linux bsd solaris mac os， 暂不支持windows GITHUB: https://github...
用于WebRTC的coturn服务器的搭建
qq_56001135的博客
12-09 1705
接下来我们要测试开启的turnserver服务器能否起作用，到测试网址：https://webrtc.github.io/samples/src/content/peerconnection/trickle-ice/准备一个自己的公网服务器，可以是阿里云或其他都可以，记得在部署时将自己的端口打开，特别是3478端口，千万记得UDP和TCP协议都要打开。turnserver -v -r 你的公网ip:3478 -a -o -c /usr/local/etc/turnserver.conf。
video-chat-webrtc:使用Socket.io和WebRTC开发的简单视频聊天应用
05-28
视讯通讯-WebRTC 使用Socket.io和WebRTC开发的简单视频聊天应用 :movie_camera:入门首先，您必须使用或 （ yarn或npm i ）作为程序包管理器来安装所有依赖项，然后再运行yarn dev或npm run dev 。 该项目将在...
com.unity.webrtc：Unity的WebRTC软件包
02-06
WebRTC for Unity WebRTC for Unity是一个软件包，允许在Unity中使用 。 如果您对使用WebRTC的流传输解决方案感兴趣，可以查看 。 文献资料 指南 如果您有兴趣在此项目中自定义本机代码，请阅读此内容。 安装 请...
WebRtcServer-master.zip
05-10
WebRTC（Web Real-Time Communication）是一项开放的网络技术，用于在浏览器和其他设备之间进行实时通信，包括音频、视频和数据共享。"WebRtcServer-master.zip"是一个包含WebRTC音视频开源项目的服务端源码库，特别...
WebRTCDemo:在Node.js上使用WebRTC视频会议和Socket.io的WebRTC演示
05-02
WebRTCDemo 说明 WebRTC Demo 程序，修改自 and ; 其中： 添加了HTTPS支持，后端使用Express发布，修改部分样式； 用于做 的Signaling Server 使用 git clone https://github.com/lanbin45/WebRTCDemo.git; cd ...
WebRTC:使用node.js和peerjs的基于WebRTC的视频聊天模块
05-19
WebRTC（Web Real-Time Communication）是一项开放的技术，它允许在浏览器之间进行实时通信，无需借助任何插件或中间件。这个技术主要用于实现浏览器内的音视频通信、数据共享等功能，极大地推动了互联网上交互式...
webrtc-qr：WebRTC连接实验-https：aquigorka.comwebrtc-qr
02-02
使用QR码在两个设备之间共享信令数据，可以建立WebRTC连接。 在桌面浏览器和移动浏览器中打开 。 在任一浏览器中选择“ Host ，在另一个浏览器中选择“ Join 托管的浏览器将显示一系列QR码（用于signalling offer...
webrtc教程（v0.3）
02-25
webrtc教程（v0.3）。初步讲解。还在继续完善中。有兴趣的同学可以一起来完善。下载后评论，可以返还积分。可在下面地址留言讨论。 http://blog.csdn.net/kl222/article/details/17198873
coturn整个流程
heidas的专栏
11-23 3865
1、通过4个协议交互 Allocate 带上用户名和密码在coturn注册上该用户信息，创建客户端发送护具的udp端口。 CreatePermission 在coturn上创建需要透传的ip+port信息。 Send Indication 客户端发数据到coturn，coturn在内存中查找是否有createPermission的ip+port，找到则直接转发到对端的udp ip+port。...
部署私有的turn/stun服务器
安迪爸爸
11-04 7813
前言 笔者在几年前就搞过webrtc，对于turn服务器这块没有做过记录，最近又要搞这个。做个记录。网上有搭建turn服务器的问题，期间遇到很多问题，我写下自己的成功案例吧。 以下的搭建过程是经过测试，可以使用的。 环境 搭建环境是centos服务器。 下载源码 可以去github上下载，https://github.com/coturn/coturn 在centos的opt目录操作 wget https://github.com/coturn/coturn/archive/master.
在阿里云Ubuntu中使用coturn创建和配置您自己的STUN/TURN服务
逍遥游的博客
07-20 2375
此前rtsp转webRTC的本地服务运行的不错，但是使用的某个免费stun服务突然被关停了，造成一些rtspToWebRTC的服务受到影响，因此，目前打算在我闲置的阿里云服务器上搭建stun/turn服务，我的域名xiaoyaoyou.xyz二级域名也一直只用在githubpage上，算是比较浪费，这里正好搭个stun/turn服务，后面看能否接到一些项目补贴一下。接下来我们或许会利用搭建好的stun/turn服务做一些小项目，比如开头提到的视频会议。httpshttpshttpshttps。...
webrtc::RTCOutboundRTPStreamStats
05-17
webrtc::RTCOutboundRTPStreamStats是WebRTC API中的一个统计数据对象，用于描述一个outbound RTP流的统计信息。它包含了发送方的一些关键指标，比如发送的字节数、丢包率、延迟等信息。 这个对象通常被用于WebRTC的性能监控和调试中，可以通过WebRTC API获取并上报给后台服务器进行分析。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

go2coding

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值