From d9cfe061b9b501511f5d769f751c8ff6bbcb1bf9 Mon Sep 17 00:00:00 2001
From: 648540858 <648540858@qq.com>
Date: 星期四, 17 八月 2023 15:20:25 +0800
Subject: [PATCH] 优化对讲释放流程
---
src/main/java/com/genersoft/iot/vmp/gb28181/transmit/event/request/impl/InviteRequestProcessor.java | 1091 +++++++++++++++++++++++++++++++-------------------------
1 files changed, 601 insertions(+), 490 deletions(-)
diff --git a/src/main/java/com/genersoft/iot/vmp/gb28181/transmit/event/request/impl/InviteRequestProcessor.java b/src/main/java/com/genersoft/iot/vmp/gb28181/transmit/event/request/impl/InviteRequestProcessor.java
index 49a4452..08eb71a 100644
--- a/src/main/java/com/genersoft/iot/vmp/gb28181/transmit/event/request/impl/InviteRequestProcessor.java
+++ b/src/main/java/com/genersoft/iot/vmp/gb28181/transmit/event/request/impl/InviteRequestProcessor.java
@@ -1,48 +1,41 @@
package com.genersoft.iot.vmp.gb28181.transmit.event.request.impl;
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONArray;
-import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONObject;
+import com.genersoft.iot.vmp.common.StreamInfo;
+import com.genersoft.iot.vmp.common.VideoManagerConstants;
import com.genersoft.iot.vmp.conf.DynamicTask;
import com.genersoft.iot.vmp.conf.SipConfig;
import com.genersoft.iot.vmp.conf.UserSetting;
import com.genersoft.iot.vmp.gb28181.bean.*;
-import com.genersoft.iot.vmp.gb28181.event.SipSubscribe;
import com.genersoft.iot.vmp.gb28181.session.AudioBroadcastManager;
-import com.genersoft.iot.vmp.gb28181.session.VideoStreamSessionManager;
+import com.genersoft.iot.vmp.gb28181.session.SSRCFactory;
import com.genersoft.iot.vmp.gb28181.transmit.SIPProcessorObserver;
-import com.genersoft.iot.vmp.gb28181.transmit.callback.DeferredResultHolder;
-import com.genersoft.iot.vmp.gb28181.transmit.callback.RequestMessage;
-import com.genersoft.iot.vmp.gb28181.transmit.cmd.ISIPCommander;
-import com.genersoft.iot.vmp.gb28181.transmit.cmd.impl.SIPCommanderFroPlatform;
+import com.genersoft.iot.vmp.gb28181.transmit.SIPSender;
+import com.genersoft.iot.vmp.gb28181.transmit.cmd.ISIPCommanderForPlatform;
import com.genersoft.iot.vmp.gb28181.transmit.event.request.ISIPRequestProcessor;
import com.genersoft.iot.vmp.gb28181.transmit.event.request.SIPRequestProcessorParent;
import com.genersoft.iot.vmp.gb28181.utils.SipUtils;
-import com.genersoft.iot.vmp.media.zlm.ZlmHttpHookSubscribe;
import com.genersoft.iot.vmp.media.zlm.ZLMMediaListManager;
-import com.genersoft.iot.vmp.media.zlm.ZLMRESTfulUtils;
-import com.genersoft.iot.vmp.media.zlm.ZLMRTPServerFactory;
+import com.genersoft.iot.vmp.media.zlm.ZLMServerFactory;
+import com.genersoft.iot.vmp.media.zlm.ZlmHttpHookSubscribe;
import com.genersoft.iot.vmp.media.zlm.dto.*;
+import com.genersoft.iot.vmp.media.zlm.dto.hook.OnStreamChangedHookParam;
import com.genersoft.iot.vmp.service.IMediaServerService;
-import com.genersoft.iot.vmp.service.IMediaService;
import com.genersoft.iot.vmp.service.IPlayService;
import com.genersoft.iot.vmp.service.IStreamProxyService;
import com.genersoft.iot.vmp.service.IStreamPushService;
+import com.genersoft.iot.vmp.service.bean.ErrorCallback;
+import com.genersoft.iot.vmp.service.bean.InviteErrorCode;
import com.genersoft.iot.vmp.service.bean.MessageForPushChannel;
import com.genersoft.iot.vmp.service.bean.SSRCInfo;
-import com.genersoft.iot.vmp.service.impl.RedisGbPlayMsgListener;
import com.genersoft.iot.vmp.service.redisMsg.RedisGbPlayMsgListener;
import com.genersoft.iot.vmp.service.redisMsg.RedisPushStreamResponseListener;
import com.genersoft.iot.vmp.storager.IRedisCatchStorage;
import com.genersoft.iot.vmp.storager.IVideoManagerStorage;
import com.genersoft.iot.vmp.utils.DateUtil;
-import com.genersoft.iot.vmp.utils.SerializeUtils;
-import com.genersoft.iot.vmp.vmanager.bean.AudioBroadcastResult;
-import com.genersoft.iot.vmp.vmanager.bean.WVPResult;
import gov.nist.javax.sdp.TimeDescriptionImpl;
import gov.nist.javax.sdp.fields.TimeField;
-import gov.nist.javax.sip.message.SIPRequest;
-import gov.nist.javax.sip.stack.SIPDialog;
import gov.nist.javax.sip.message.SIPRequest;
import gov.nist.javax.sip.message.SIPResponse;
import org.slf4j.Logger;
@@ -52,12 +45,16 @@
import org.springframework.stereotype.Component;
import javax.sdp.*;
-import javax.sip.*;
+import javax.sip.InvalidArgumentException;
+import javax.sip.RequestEvent;
+import javax.sip.SipException;
import javax.sip.header.CallIdHeader;
-import javax.sip.message.Request;
import javax.sip.message.Response;
import java.text.ParseException;
import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
import java.util.Vector;
/**
@@ -72,7 +69,7 @@
private final String method = "INVITE";
@Autowired
- private SIPCommanderFroPlatform cmderFroPlatform;
+ private ISIPCommanderForPlatform cmderFroPlatform;
@Autowired
private IVideoManagerStorage storager;
@@ -87,6 +84,9 @@
private IRedisCatchStorage redisCatchStorage;
@Autowired
+ private SSRCFactory ssrcFactory;
+
+ @Autowired
private DynamicTask dynamicTask;
@Autowired
@@ -96,22 +96,16 @@
private IPlayService playService;
@Autowired
- private ISIPCommander commander;
-
- @Autowired
- private AudioBroadcastManager audioBroadcastManager;
+ private SIPSender sipSender;
@Autowired
- private ZLMRTPServerFactory zlmrtpServerFactory;
+ private AudioBroadcastManager audioBroadcastManager;
+
+ @Autowired
+ private ZLMServerFactory zlmServerFactory;
@Autowired
private IMediaServerService mediaServerService;
-
- @Autowired
- private IMediaService mediaService;
-
- @Autowired
- private ZLMRESTfulUtils zlmresTfulUtils;
@Autowired
private ZlmHttpHookSubscribe zlmHttpHookSubscribe;
@@ -120,23 +114,13 @@
private SIPProcessorObserver sipProcessorObserver;
@Autowired
- private VideoStreamSessionManager sessionManager;
-
- @Autowired
private UserSetting userSetting;
@Autowired
private ZLMMediaListManager mediaListManager;
- @Autowired
- private DeferredResultHolder resultHolder;
-
- @Autowired
- private ZlmHttpHookSubscribe subscribe;
-
- @Autowired
- private SipConfig config;
-
+ @Autowired
+ private SipConfig config;
@Autowired
@@ -158,15 +142,18 @@
public void process(RequestEvent evt) {
// Invite Request娑堟伅瀹炵幇锛屾娑堟伅涓�鑸负绾ц仈娑堟伅锛屼笂绾х粰涓嬬骇鍙戦�佽姹傝棰戞寚浠�
try {
- Request request = evt.getRequest();
+ SIPRequest request = (SIPRequest) evt.getRequest();
String channelId = SipUtils.getChannelIdFromRequest(request);
String requesterId = SipUtils.getUserIdFromFromHeader(request);
CallIdHeader callIdHeader = (CallIdHeader) request.getHeader(CallIdHeader.NAME);
- ServerTransaction serverTransaction = getServerTransaction(evt);
if (requesterId == null || channelId == null) {
logger.info("鏃犳硶浠嶧romHeader鐨凙ddress涓幏鍙栧埌骞冲彴id锛岃繑鍥�400");
// 鍙傛暟涓嶅叏锛� 鍙�400锛岃姹傞敊璇�
- responseAck(serverTransaction, Response.BAD_REQUEST);
+ try {
+ responseAck(request, Response.BAD_REQUEST);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite BAD_REQUEST: {}", e.getMessage());
+ }
return;
}
@@ -174,25 +161,25 @@
// 鏌ヨ璇锋眰鏄惁鏉ヨ嚜涓婄骇骞冲彴\璁惧
ParentPlatform platform = storager.queryParentPlatByServerGBId(requesterId);
if (platform == null) {
- inviteFromDeviceHandle(serverTransaction, requesterId);
+ inviteFromDeviceHandle(request, requesterId, channelId);
+
} else {
// 鏌ヨ骞冲彴涓嬫槸鍚︽湁璇ラ�氶亾
DeviceChannel channel = storager.queryChannelInParentPlatform(requesterId, channelId);
GbStream gbStream = storager.queryStreamInParentPlatform(requesterId, channelId);
- PlatformCatalog catalog = storager.getCatalog(channelId);
+ PlatformCatalog catalog = storager.getCatalog(requesterId, channelId);
MediaServerItem mediaServerItem = null;
StreamPushItem streamPushItem = null;
- StreamProxyItem proxyByAppAndStream =null;
+ StreamProxyItem proxyByAppAndStream = null;
// 涓嶆槸閫氶亾鍙兘鏄洿鎾祦
if (channel != null && gbStream == null) {
-// if (channel.getStatus() == 0) {
-// logger.info("閫氶亾绂荤嚎锛岃繑鍥�400");
-// responseAck(serverTransaction, Response.BAD_REQUEST, "channel [" + channel.getChannelId() + "] offline");
-// return;
-// }
// 閫氶亾瀛樺湪锛屽彂100锛孴RYING
- responseAck(serverTransaction, Response.TRYING);
+ try {
+ responseAck(request, Response.TRYING);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite TRYING: {}", e.getMessage());
+ }
} else if (channel == null && gbStream != null) {
String mediaServerId = gbStream.getMediaServerId();
@@ -200,14 +187,19 @@
if (mediaServerItem == null) {
if ("proxy".equals(gbStream.getStreamType())) {
logger.info("[ app={}, stream={} ]鎵句笉鍒皕lm {}锛岃繑鍥�410", gbStream.getApp(), gbStream.getStream(), mediaServerId);
- responseAck(serverTransaction, Response.GONE);
+ try {
+ responseAck(request, Response.GONE);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite GONE: {}", e.getMessage());
+ }
return;
} else {
streamPushItem = streamPushService.getPush(gbStream.getApp(), gbStream.getStream());
- if (streamPushItem == null || streamPushItem.getServerId().equals(userSetting.getServerId())) {
- logger.info("[ app={}, stream={} ]鎵句笉鍒皕lm {}锛岃繑鍥�410", gbStream.getApp(), gbStream.getStream(), mediaServerId);
- responseAck(serverTransaction, Response.GONE);
- return;
+ if (streamPushItem != null) {
+ mediaServerItem = mediaServerService.getOne(streamPushItem.getMediaServerId());
+ }
+ if (mediaServerItem == null) {
+ mediaServerItem = mediaServerService.getDefaultMediaServer();
}
}
} else {
@@ -215,45 +207,54 @@
streamPushItem = streamPushService.getPush(gbStream.getApp(), gbStream.getStream());
if (streamPushItem == null) {
logger.info("[ app={}, stream={} ]鎵句笉鍒皕lm {}锛岃繑鍥�410", gbStream.getApp(), gbStream.getStream(), mediaServerId);
- responseAck(serverTransaction, Response.GONE);
+ try {
+ responseAck(request, Response.GONE);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite GONE: {}", e.getMessage());
+ }
return;
}
- }else if("proxy".equals(gbStream.getStreamType())){
+ } else if ("proxy".equals(gbStream.getStreamType())) {
proxyByAppAndStream = streamProxyService.getStreamProxyByAppAndStream(gbStream.getApp(), gbStream.getStream());
if (proxyByAppAndStream == null) {
logger.info("[ app={}, stream={} ]鎵句笉鍒皕lm {}锛岃繑鍥�410", gbStream.getApp(), gbStream.getStream(), mediaServerId);
- responseAck(serverTransaction, Response.GONE);
+ try {
+ responseAck(request, Response.GONE);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite GONE: {}", e.getMessage());
+ }
return;
}
}
}
- responseAck(serverTransaction, Response.CALL_IS_BEING_FORWARDED); // 閫氶亾瀛樺湪锛屽彂181锛屽懠鍙浆鎺ヤ腑
+ try {
+ responseAck(request, Response.CALL_IS_BEING_FORWARDED);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite CALL_IS_BEING_FORWARDED: {}", e.getMessage());
+ }
} else if (catalog != null) {
- responseAck(serverTransaction, Response.BAD_REQUEST, "catalog channel can not play"); // 鐩綍涓嶆敮鎸佺偣鎾�
+ try {
+ // 鐩綍涓嶆敮鎸佺偣鎾�
+ responseAck(request, Response.BAD_REQUEST, "catalog channel can not play");
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 鐩綍涓嶆敮鎸佺偣鎾�: {}", e.getMessage());
+ }
return;
} else {
- logger.info("閫氶亾涓嶅瓨鍦紝杩斿洖404");
- responseAck(serverTransaction, Response.NOT_FOUND); // 閫氶亾涓嶅瓨鍦紝鍙�404锛岃祫婧愪笉瀛樺湪
+ logger.info("閫氶亾涓嶅瓨鍦紝杩斿洖404: {}", channelId);
+ try {
+ // 閫氶亾涓嶅瓨鍦紝鍙�404锛岃祫婧愪笉瀛樺湪
+ responseAck(request, Response.NOT_FOUND);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 閫氶亾涓嶅瓨鍦�: {}", e.getMessage());
+ }
return;
}
// 瑙ｆ瀽sdp娑堟伅, 浣跨敤jainsip 鑷甫鐨剆dp瑙ｆ瀽鏂瑰紡
String contentString = new String(request.getRawContent());
- // jainSip涓嶆敮鎸亂=瀛楁锛� 绉婚櫎浠ヨВ鏋愩��
- int ssrcIndex = contentString.indexOf("y=");
- // 妫�鏌ユ槸鍚︽湁y瀛楁
- String ssrcDefault = "0000000000";
- String ssrc;
- SessionDescription sdp;
- if (ssrcIndex >= 0) {
- //ssrc瑙勫畾闀垮害涓�10涓瓧鑺傦紝涓嶅彇浣欎笅闀垮害浠ラ伩鍏嶅悗缁繕鏈夆�渇=鈥濆瓧娈�
- ssrc = contentString.substring(ssrcIndex + 2, ssrcIndex + 12);
- String substring = contentString.substring(0, contentString.indexOf("y="));
- sdp = SdpFactory.getInstance().createSessionDescription(substring);
- } else {
- ssrc = ssrcDefault;
- sdp = SdpFactory.getInstance().createSessionDescription(contentString);
- }
+ Gb28181Sdp gb28181Sdp = SipUtils.parseSDP(contentString);
+ SessionDescription sdp = gb28181Sdp.getBaseSdb();
String sessionName = sdp.getSessionName().getValue();
Long startTime = null;
@@ -304,38 +305,73 @@
if (port == -1) {
logger.info("涓嶆敮鎸佺殑濯掍綋鏍煎紡锛岃繑鍥�415");
// 鍥炲涓嶆敮鎸佺殑鏍煎紡
- responseAck(serverTransaction, Response.UNSUPPORTED_MEDIA_TYPE); // 涓嶆敮鎸佺殑鏍煎紡锛屽彂415
+ try {
+ // 涓嶆敮鎸佺殑鏍煎紡锛屽彂415
+ responseAck(request, Response.UNSUPPORTED_MEDIA_TYPE);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 涓嶆敮鎸佺殑鏍煎紡: {}", e.getMessage());
+ }
return;
}
String username = sdp.getOrigin().getUsername();
- String addressStr = sdp.getOrigin().getAddress();
+ String addressStr = sdp.getConnection().getAddress();
- logger.info("[涓婄骇鐐规挱]鐢ㄦ埛锛歿}锛� 閫氶亾锛歿}, 鍦板潃锛歿}:{}锛� ssrc锛歿}", username, channelId, addressStr, port, ssrc);
+
Device device = null;
// 閫氳繃 channel 鍜� gbStream 鏄惁涓簄ull 鍊煎垽鏂潵婧愭槸鐩存挱娴佸悎閫傚浗鏍�
if (channel != null) {
device = storager.queryVideoDeviceByPlatformIdAndChannelId(requesterId, channelId);
if (device == null) {
logger.warn("鐐规挱骞冲彴{}鐨勯�氶亾{}鏃舵湭鎵惧埌璁惧淇℃伅", requesterId, channel);
- responseAck(serverTransaction, Response.SERVER_INTERNAL_ERROR);
+ try {
+ responseAck(request, Response.SERVER_INTERNAL_ERROR);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 鏈壘鍒拌澶囦俊鎭�: {}", e.getMessage());
+ }
return;
}
mediaServerItem = playService.getNewMediaServerItem(device);
if (mediaServerItem == null) {
logger.warn("鏈壘鍒板彲鐢ㄧ殑zlm");
- responseAck(serverTransaction, Response.BUSY_HERE);
+ try {
+ responseAck(request, Response.BUSY_HERE);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite BUSY_HERE: {}", e.getMessage());
+ }
return;
}
- SendRtpItem sendRtpItem = zlmrtpServerFactory.createSendRtpItem(mediaServerItem, addressStr, port, ssrc, requesterId,
- device.getDeviceId(), channelId,
- mediaTransmissionTCP);
+
+ String ssrc;
+ if (userSetting.getUseCustomSsrcForParentInvite() || gb28181Sdp.getSsrc() == null) {
+ // 涓婄骇骞冲彴鐐规挱鏃朵笉浣跨敤涓婄骇骞冲彴鎸囧畾鐨剆src锛屼娇鐢ㄨ嚜瀹氫箟鐨剆src锛屽弬鑰冨浗鏍囨枃妗�-鐐规挱澶栧煙璁惧濯掍綋娴丼SRC澶勭悊鏂瑰紡
+ ssrc = "Play".equalsIgnoreCase(sessionName) ? ssrcFactory.getPlaySsrc(mediaServerItem.getId()) : ssrcFactory.getPlayBackSsrc(mediaServerItem.getId());
+ }else {
+ ssrc = gb28181Sdp.getSsrc();
+ }
+ String streamTypeStr = null;
+ if (mediaTransmissionTCP) {
+ if (tcpActive) {
+ streamTypeStr = "TCP-ACTIVE";
+ } else {
+ streamTypeStr = "TCP-PASSIVE";
+ }
+ } else {
+ streamTypeStr = "UDP";
+ }
+ logger.info("[涓婄骇Invite] {}, 骞冲彴锛歿}锛� 閫氶亾锛歿}, 鏀舵祦鍦板潃锛歿}:{}锛屾敹娴佹柟寮忥細{}, ssrc锛歿}", sessionName, username, channelId, addressStr, port, streamTypeStr, ssrc);
+ SendRtpItem sendRtpItem = zlmServerFactory.createSendRtpItem(mediaServerItem, addressStr, port, ssrc, requesterId,
+ device.getDeviceId(), channelId, mediaTransmissionTCP, platform.isRtcp());
if (tcpActive != null) {
sendRtpItem.setTcpActive(tcpActive);
}
if (sendRtpItem == null) {
logger.warn("鏈嶅姟鍣ㄧ鍙ｈ祫婧愪笉瓒�");
- responseAck(serverTransaction, Response.BUSY_HERE);
+ try {
+ responseAck(request, Response.BUSY_HERE);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 鏈嶅姟鍣ㄧ鍙ｈ祫婧愪笉瓒�: {}", e.getMessage());
+ }
return;
}
sendRtpItem.setCallId(callIdHeader.getCallId());
@@ -343,10 +379,10 @@
Long finalStartTime = startTime;
Long finalStopTime = stopTime;
- ZlmHttpHookSubscribe.Event hookEvent = (mediaServerItemInUSe, responseJSON) -> {
- String app = responseJSON.getString("app");
- String stream = responseJSON.getString("stream");
- logger.info("[涓婄骇鐐规挱]涓嬬骇宸茬粡寮�濮嬫帹娴併�� 鍥炲200OK(SDP)锛� {}/{}", app, stream);
+ ErrorCallback<Object> hookEvent = (code, msg, data) -> {
+ StreamInfo streamInfo = (StreamInfo)data;
+ MediaServerItem mediaServerItemInUSe = mediaServerService.getOne(streamInfo.getMediaServerId());
+ logger.info("[涓婄骇Invite]涓嬬骇宸茬粡寮�濮嬫帹娴併�� 鍥炲200OK(SDP)锛� {}/{}", streamInfo.getApp(), streamInfo.getStream());
// * 0 绛夊緟璁惧鎺ㄦ祦涓婃潵
// * 1 涓嬬骇宸茬粡鎺ㄦ祦锛岀瓑寰呬笂绾у钩鍙板洖澶峚ck
// * 2 鎺ㄦ祦涓�
@@ -363,11 +399,17 @@
} else {
content.append("t=0 0\r\n");
}
- content.append("m=video " + sendRtpItem.getLocalPort() + " RTP/AVP 96\r\n");
+ int localPort = sendRtpItem.getLocalPort();
+ if (localPort == 0) {
+ // 闈炰弗鏍兼ā寮忕鍙ｄ笉缁熶竴, 澧炲姞鍏煎鎬э紝淇敼涓轰竴涓笉涓�0鐨勭鍙�
+ localPort = new Random().nextInt(65535) + 1;
+ }
+ content.append("m=video " + localPort + " RTP/AVP 96\r\n");
content.append("a=sendonly\r\n");
content.append("a=rtpmap:96 PS/90000\r\n");
content.append("y=" + sendRtpItem.getSsrc() + "\r\n");
content.append("f=\r\n");
+
try {
// 瓒呮椂鏈敹鍒癆ck搴旇鍥炲bye,褰撳墠绛夊緟鏃堕棿涓�10绉�
@@ -381,199 +423,236 @@
logger.error("[鍛戒护鍙戦�佸け璐 鍥芥爣绾ц仈 鍙戦�丅YE: {}", e.getMessage());
}
}, 60 * 1000);
- responseSdpAck(serverTransaction, content.toString(), platform);
-
- } catch (SipException e) {
- e.printStackTrace();
- } catch (InvalidArgumentException e) {
- e.printStackTrace();
- } catch (ParseException e) {
- e.printStackTrace();
+ responseSdpAck(request, content.toString(), platform);
+ // tcp涓诲姩妯″紡锛屽洖澶峴dp鍚庡紑鍚洃鍚�
+ if (sendRtpItem.isTcpActive()) {
+ MediaServerItem mediaInfo = mediaServerService.getOne(sendRtpItem.getMediaServerId());
+ Map<String, Object> param = new HashMap<>(12);
+ param.put("vhost","__defaultVhost__");
+ param.put("app",sendRtpItem.getApp());
+ param.put("stream",sendRtpItem.getStream());
+ param.put("ssrc", sendRtpItem.getSsrc());
+ if (!sendRtpItem.isTcpActive()) {
+ param.put("dst_url",sendRtpItem.getIp());
+ param.put("dst_port", sendRtpItem.getPort());
+ }
+ String is_Udp = sendRtpItem.isTcp() ? "0" : "1";
+ param.put("is_udp", is_Udp);
+ param.put("src_port", localPort);
+ param.put("pt", sendRtpItem.getPt());
+ param.put("use_ps", sendRtpItem.isUsePs() ? "1" : "0");
+ param.put("only_audio", sendRtpItem.isOnlyAudio() ? "1" : "0");
+ if (!sendRtpItem.isTcp()) {
+ // 寮�鍚痳tcp淇濇椿
+ param.put("udp_rtcp_timeout", sendRtpItem.isRtcp()? "1":"0");
+ }
+ JSONObject startSendRtpStreamResult = zlmServerFactory.startSendRtpPassive(mediaInfo, param);
+ if (startSendRtpStreamResult != null) {
+ startSendRtpStreamHand(evt, sendRtpItem, null, startSendRtpStreamResult, param, callIdHeader);
+ }
+ }
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 鍥芥爣绾ц仈 鍥炲SdpAck", e);
}
};
- SipSubscribe.Event errorEvent = ((event) -> {
+ ErrorCallback<Object> errorEvent = ((statusCode, msg, data) -> {
// 鏈煡閿欒銆傜洿鎺ヨ浆鍙戣澶囩偣鎾殑閿欒
- Response response = null;
try {
- response = getMessageFactory().createResponse(event.statusCode, evt.getRequest());
- serverTransaction.sendResponse(response);
- System.out.println("鏈煡閿欒銆傜洿鎺ヨ浆鍙戣澶囩偣鎾殑閿欒");
- if (serverTransaction.getDialog() != null) {
- serverTransaction.getDialog().delete();
+ if (statusCode > 0) {
+ Response response = getMessageFactory().createResponse(statusCode, evt.getRequest());
+ sipSender.transmitRequest(request.getLocalAddress().getHostAddress(), response);
}
- } catch (ParseException | SipException | InvalidArgumentException e) {
- e.printStackTrace();
+ } catch (ParseException | SipException e) {
+ logger.error("鏈鐞嗙殑寮傚父 ", e);
}
});
sendRtpItem.setApp("rtp");
if ("Playback".equalsIgnoreCase(sessionName)) {
sendRtpItem.setPlayType(InviteStreamType.PLAYBACK);
- SSRCInfo ssrcInfo = mediaServerService.openRTPServer(mediaServerItem, null, true, true);
- sendRtpItem.setStreamId(ssrcInfo.getStream());
+ String startTimeStr = DateUtil.urlFormatter.format(start);
+ String endTimeStr = DateUtil.urlFormatter.format(end);
+ String stream = device.getDeviceId() + "_" + channelId + "_" + startTimeStr + "_" + endTimeStr;
+ SSRCInfo ssrcInfo = mediaServerService.openRTPServer(mediaServerItem, stream, null, device.isSsrcCheck(), true, 0,false, false, device.getStreamModeForParam());
// 鍐欏叆redis锛� 瓒呮椂鏃跺洖澶�
redisCatchStorage.updateSendRTPSever(sendRtpItem);
playService.playBack(mediaServerItem, ssrcInfo, device.getDeviceId(), channelId, DateUtil.formatter.format(start),
- DateUtil.formatter.format(end), null, result -> {
- if (result.getCode() != 0) {
- logger.warn("褰曞儚鍥炴斁澶辫触");
- if (result.getEvent() != null) {
- errorEvent.response(result.getEvent());
- }
+ DateUtil.formatter.format(end),
+ (code, msg, data) -> {
+ if (code == InviteErrorCode.SUCCESS.getCode()) {
+ hookEvent.run(code, msg, data);
+ } else if (code == InviteErrorCode.ERROR_FOR_SIGNALLING_TIMEOUT.getCode() || code == InviteErrorCode.ERROR_FOR_STREAM_TIMEOUT.getCode()) {
+ logger.info("[褰曞儚鍥炴斁]瓒呮椂, 鐢ㄦ埛锛歿}锛� 閫氶亾锛歿}", username, channelId);
redisCatchStorage.deleteSendRTPServer(platform.getServerGBId(), channelId, callIdHeader.getCallId(), null);
- try {
- responseAck(serverTransaction, Response.REQUEST_TIMEOUT);
- } catch (SipException e) {
- e.printStackTrace();
- } catch (InvalidArgumentException e) {
- e.printStackTrace();
- } catch (ParseException e) {
- e.printStackTrace();
- }
+ errorEvent.run(code, msg, data);
} else {
- if (result.getMediaServerItem() != null) {
- hookEvent.response(result.getMediaServerItem(), result.getResponse());
- }
+ errorEvent.run(code, msg, data);
}
});
- } else {
- sendRtpItem.setPlayType(InviteStreamType.PLAY);
- SsrcTransaction playTransaction = sessionManager.getSsrcTransaction(device.getDeviceId(), channelId, "play", null);
- if (playTransaction != null) {
- Boolean streamReady = zlmrtpServerFactory.isStreamReady(mediaServerItem, "rtp", playTransaction.getStream());
- if (!streamReady) {
- boolean hasRtpServer = mediaServerService.checkRtpServer(mediaServerItem, "rtp", playTransaction.getStream());
- if (hasRtpServer) {
- logger.info("[涓婄骇鐐规挱]宸茬粡寮�鍚痳tpServer浣嗘槸灏氭湭鏀跺埌娴侊紝寮�鍚洃鍚祦鐨勫埌鏉�");
- HookSubscribeForStreamChange hookSubscribe = HookSubscribeFactory.on_stream_changed("rtp", playTransaction.getStream(), true, "rtsp", mediaServerItem.getId());
- zlmHttpHookSubscribe.addSubscribe(hookSubscribe, hookEvent);
- }else {
- playTransaction = null;
- }
- }
+ } else if ("Download".equalsIgnoreCase(sessionName)) {
+ // 鑾峰彇鎸囧畾鐨勪笅杞介�熷害
+ Vector sdpMediaDescriptions = sdp.getMediaDescriptions(true);
+ MediaDescription mediaDescription = null;
+ String downloadSpeed = "1";
+ if (sdpMediaDescriptions.size() > 0) {
+ mediaDescription = (MediaDescription) sdpMediaDescriptions.get(0);
}
- if (playTransaction == null) {
- String streamId = null;
- if (mediaServerItem.isRtpEnable()) {
- streamId = String.format("%s_%s", device.getDeviceId(), channelId);
- }
- SSRCInfo ssrcInfo = mediaServerService.openRTPServer(mediaServerItem, streamId, null, device.isSsrcCheck(), false);
- logger.info(JSONObject.toJSONString(ssrcInfo));
- sendRtpItem.setStreamId(ssrcInfo.getStream());
- sendRtpItem.setSsrc(ssrc.equals(ssrcDefault) ? ssrcInfo.getSsrc() : ssrc);
+ if (mediaDescription != null) {
+ downloadSpeed = mediaDescription.getAttribute("downloadspeed");
+ }
- // 鍐欏叆redis锛� 瓒呮椂鏃跺洖澶�
- redisCatchStorage.updateSendRTPSever(sendRtpItem);
- playService.play(mediaServerItem, ssrcInfo, device, channelId, hookEvent, errorEvent, (code, msg) -> {
+ sendRtpItem.setPlayType(InviteStreamType.DOWNLOAD);
+ SSRCInfo ssrcInfo = mediaServerService.openRTPServer(mediaServerItem, null, null, device.isSsrcCheck(), true, 0, false, false, device.getStreamModeForParam());
+ sendRtpItem.setStream(ssrcInfo.getStream());
+ // 鍐欏叆redis锛� 瓒呮椂鏃跺洖澶�
+ redisCatchStorage.updateSendRTPSever(sendRtpItem);
+ playService.download(mediaServerItem, ssrcInfo, device.getDeviceId(), channelId, DateUtil.formatter.format(start),
+ DateUtil.formatter.format(end), Integer.parseInt(downloadSpeed),
+ (code, msg, data) -> {
+ if (code == InviteErrorCode.SUCCESS.getCode()) {
+ hookEvent.run(code, msg, data);
+ } else if (code == InviteErrorCode.ERROR_FOR_SIGNALLING_TIMEOUT.getCode() || code == InviteErrorCode.ERROR_FOR_STREAM_TIMEOUT.getCode()) {
+ logger.info("[褰曞儚涓嬭浇]瓒呮椂, 鐢ㄦ埛锛歿}锛� 閫氶亾锛歿}", username, channelId);
+ redisCatchStorage.deleteSendRTPServer(platform.getServerGBId(), channelId, callIdHeader.getCallId(), null);
+ errorEvent.run(code, msg, data);
+ } else {
+ errorEvent.run(code, msg, data);
+ }
+ });
+ }else {
+
+ SSRCInfo ssrcInfo = playService.play(mediaServerItem, device.getDeviceId(), channelId, ssrc, ((code, msg, data) -> {
+ if (code == InviteErrorCode.SUCCESS.getCode()){
+ hookEvent.run(code, msg, data);
+ } else if (code == InviteErrorCode.ERROR_FOR_SIGNALLING_TIMEOUT.getCode() || code == InviteErrorCode.ERROR_FOR_STREAM_TIMEOUT.getCode()) {
logger.info("[涓婄骇鐐规挱]瓒呮椂, 鐢ㄦ埛锛歿}锛� 閫氶亾锛歿}", username, channelId);
redisCatchStorage.deleteSendRTPServer(platform.getServerGBId(), channelId, callIdHeader.getCallId(), null);
- }, null);
- } else {
- sendRtpItem.setStreamId(playTransaction.getStream());
- // 鍐欏叆redis锛� 瓒呮椂鏃跺洖澶�
- redisCatchStorage.updateSendRTPSever(sendRtpItem);
- JSONObject jsonObject = new JSONObject();
- jsonObject.put("app", sendRtpItem.getApp());
- jsonObject.put("stream", sendRtpItem.getStreamId());
- hookEvent.response(mediaServerItem, jsonObject);
- }
+ errorEvent.run(code, msg, data);
+ } else {
+ errorEvent.run(code, msg, data);
+ }
+ }));
+ sendRtpItem.setPlayType(InviteStreamType.PLAY);
+ String streamId = String.format("%s_%s", device.getDeviceId(), channelId);
+ sendRtpItem.setStream(streamId);
+ sendRtpItem.setSsrc(ssrcInfo.getSsrc());
+ redisCatchStorage.updateSendRTPSever(sendRtpItem);
+
}
} else if (gbStream != null) {
- if("push".equals(gbStream.getStreamType())) {
+
+ String ssrc;
+ if (userSetting.getUseCustomSsrcForParentInvite() || gb28181Sdp.getSsrc() == null) {
+ // 涓婄骇骞冲彴鐐规挱鏃朵笉浣跨敤涓婄骇骞冲彴鎸囧畾鐨剆src锛屼娇鐢ㄨ嚜瀹氫箟鐨剆src锛屽弬鑰冨浗鏍囨枃妗�-鐐规挱澶栧煙璁惧濯掍綋娴丼SRC澶勭悊鏂瑰紡
+ ssrc = "Play".equalsIgnoreCase(sessionName) ? ssrcFactory.getPlaySsrc(mediaServerItem.getId()) : ssrcFactory.getPlayBackSsrc(mediaServerItem.getId());
+ }else {
+ ssrc = gb28181Sdp.getSsrc();
+ }
+
+ if ("push".equals(gbStream.getStreamType())) {
if (streamPushItem != null && streamPushItem.isPushIng()) {
// 鎺ㄦ祦鐘舵��
- pushStream(evt, serverTransaction, gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
+ pushStream(evt, request, gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
} else {
// 鏈帹娴� 鎷夎捣
- notifyStreamOnline(evt, serverTransaction,gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
+ notifyStreamOnline(evt, request, gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
}
- }else if ("proxy".equals(gbStream.getStreamType())){
- if(null != proxyByAppAndStream &&proxyByAppAndStream.isStatus()){
- pushProxyStream(evt, serverTransaction, gbStream, platform, callIdHeader, mediaServerItem, port, tcpActive,
- mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
- }else{
- //寮�鍚唬鐞嗘媺娴�
- boolean start1 = streamProxyService.start(gbStream.getApp(), gbStream.getStream());
- if(start1) {
- pushProxyStream(evt, serverTransaction, gbStream, platform, callIdHeader, mediaServerItem, port, tcpActive,
+ } else if ("proxy".equals(gbStream.getStreamType())) {
+ if (null != proxyByAppAndStream) {
+ if (proxyByAppAndStream.isStatus()) {
+ pushProxyStream(evt, request, gbStream, platform, callIdHeader, mediaServerItem, port, tcpActive,
mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
- }else{
- //澶辫触鍚庨�氱煡
- notifyStreamOnline(evt, serverTransaction,gbStream, null, platform, callIdHeader, mediaServerItem, port, tcpActive,
+ } else {
+ //寮�鍚唬鐞嗘媺娴�
+ notifyStreamOnline(evt, request, gbStream, null, platform, callIdHeader, mediaServerItem, port, tcpActive,
mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
}
}
+
}
}
}
-
- } catch (SipException | InvalidArgumentException | ParseException e) {
- e.printStackTrace();
- logger.warn("sdp瑙ｆ瀽閿欒");
- e.printStackTrace();
} catch (SdpParseException e) {
- e.printStackTrace();
+ logger.error("sdp瑙ｆ瀽閿欒", e);
} catch (SdpException e) {
- e.printStackTrace();
+ logger.error("鏈鐞嗙殑寮傚父 ", e);
+ }
+ }
+
+ private void startSendRtpStreamHand(RequestEvent evt, SendRtpItem sendRtpItem, ParentPlatform parentPlatform,
+ JSONObject jsonObject, Map<String, Object> param, CallIdHeader callIdHeader) {
+ if (jsonObject == null) {
+ logger.error("涓嬬骇TCP琚姩鍚姩鐩戝惉澶辫触: 璇锋鏌LM鏈嶅姟");
+ } else if (jsonObject.getInteger("code") == 0) {
+ logger.info("璋冪敤ZLM-TCP琚姩鎺ㄦ祦鎺ュ彛, 缁撴灉锛� {}", jsonObject);
+ logger.info("鍚姩鐩戝惉TCP琚姩鎺ㄦ祦鎴愬姛[ {}/{} ]锛寋}->{}:{}, " ,param.get("app"), param.get("stream"), jsonObject.getString("local_port"), param.get("dst_url"), param.get("dst_port"));
+ } else {
+ logger.error("鍚姩鐩戝惉TCP琚姩鎺ㄦ祦澶辫触: {}, 鍙傛暟锛歿}",jsonObject.getString("msg"), JSON.toJSONString(param));
}
}
/**
* 瀹夋帓鎺ㄦ祦
*/
- private void pushProxyStream(RequestEvent evt, ServerTransaction serverTransaction, GbStream gbStream, ParentPlatform platform,
+ private void pushProxyStream(RequestEvent evt, SIPRequest request, GbStream gbStream, ParentPlatform platform,
CallIdHeader callIdHeader, MediaServerItem mediaServerItem,
int port, Boolean tcpActive, boolean mediaTransmissionTCP,
- String channelId, String addressStr, String ssrc, String requesterId) throws InvalidArgumentException, ParseException, SipException {
- Boolean streamReady = zlmrtpServerFactory.isStreamReady(mediaServerItem, gbStream.getApp(), gbStream.getStream());
- if (streamReady) {
+ String channelId, String addressStr, String ssrc, String requesterId) {
+ Boolean streamReady = zlmServerFactory.isStreamReady(mediaServerItem, gbStream.getApp(), gbStream.getStream());
+ if (streamReady != null && streamReady) {
// 鑷钩鍙板唴瀹�
- SendRtpItem sendRtpItem = zlmrtpServerFactory.createSendRtpItem(mediaServerItem, addressStr, port, ssrc, requesterId,
- gbStream.getApp(), gbStream.getStream(), channelId,
- mediaTransmissionTCP);
+ SendRtpItem sendRtpItem = zlmServerFactory.createSendRtpItem(mediaServerItem, addressStr, port, ssrc, requesterId,
+ gbStream.getApp(), gbStream.getStream(), channelId, mediaTransmissionTCP, platform.isRtcp());
- if (sendRtpItem == null) {
- logger.warn("鏈嶅姟鍣ㄧ鍙ｈ祫婧愪笉瓒�");
- responseAck(serverTransaction, Response.BUSY_HERE);
- return;
+ if (sendRtpItem == null) {
+ logger.warn("鏈嶅姟鍣ㄧ鍙ｈ祫婧愪笉瓒�");
+ try {
+ responseAck(request, Response.BUSY_HERE);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 鏈嶅姟鍣ㄧ鍙ｈ祫婧愪笉瓒�: {}", e.getMessage());
}
- if (tcpActive != null) {
- sendRtpItem.setTcpActive(tcpActive);
- }
- sendRtpItem.setPlayType(InviteStreamType.PUSH);
- // 鍐欏叆redis锛� 瓒呮椂鏃跺洖澶�
- sendRtpItem.setStatus(1);
- sendRtpItem.setCallId(callIdHeader.getCallId());
- SIPRequest request = (SIPRequest) evt.getRequest();
- sendRtpItem.setFromTag(request.getFromTag());
+ return;
+ }
+ if (tcpActive != null) {
+ sendRtpItem.setTcpActive(tcpActive);
+ }
+ sendRtpItem.setPlayType(InviteStreamType.PUSH);
+ // 鍐欏叆redis锛� 瓒呮椂鏃跺洖澶�
+ sendRtpItem.setStatus(1);
+ sendRtpItem.setCallId(callIdHeader.getCallId());
+ sendRtpItem.setFromTag(request.getFromTag());
- SIPResponse response = sendStreamAck(mediaServerItem, serverTransaction, sendRtpItem, platform, evt);
- if (response != null) {
- sendRtpItem.setToTag(response.getToTag());
- }
- redisCatchStorage.updateSendRTPSever(sendRtpItem);
+ SIPResponse response = sendStreamAck(mediaServerItem, request, sendRtpItem, platform, evt);
+ if (response != null) {
+ sendRtpItem.setToTag(response.getToTag());
+ }
+ redisCatchStorage.updateSendRTPSever(sendRtpItem);
}
}
- private void pushStream(RequestEvent evt, ServerTransaction serverTransaction, GbStream gbStream, StreamPushItem streamPushItem, ParentPlatform platform,
+
+ private void pushStream(RequestEvent evt, SIPRequest request, GbStream gbStream, StreamPushItem streamPushItem, ParentPlatform platform,
CallIdHeader callIdHeader, MediaServerItem mediaServerItem,
int port, Boolean tcpActive, boolean mediaTransmissionTCP,
- String channelId, String addressStr, String ssrc, String requesterId) throws InvalidArgumentException, ParseException, SipException {
+ String channelId, String addressStr, String ssrc, String requesterId) {
// 鎺ㄦ祦
if (streamPushItem.isSelf()) {
- Boolean streamReady = zlmrtpServerFactory.isStreamReady(mediaServerItem, gbStream.getApp(), gbStream.getStream());
- if (streamReady) {
+ Boolean streamReady = zlmServerFactory.isStreamReady(mediaServerItem, gbStream.getApp(), gbStream.getStream());
+ if (streamReady != null && streamReady) {
// 鑷钩鍙板唴瀹�
- SendRtpItem sendRtpItem = zlmrtpServerFactory.createSendRtpItem(mediaServerItem, addressStr, port, ssrc, requesterId,
- gbStream.getApp(), gbStream.getStream(), channelId,
- mediaTransmissionTCP);
+ SendRtpItem sendRtpItem = zlmServerFactory.createSendRtpItem(mediaServerItem, addressStr, port, ssrc, requesterId,
+ gbStream.getApp(), gbStream.getStream(), channelId, mediaTransmissionTCP, platform.isRtcp());
if (sendRtpItem == null) {
logger.warn("鏈嶅姟鍣ㄧ鍙ｈ祫婧愪笉瓒�");
- responseAck(serverTransaction, Response.BUSY_HERE);
+ try {
+ responseAck(request, Response.BUSY_HERE);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 鏈嶅姟鍣ㄧ鍙ｈ祫婧愪笉瓒�: {}", e.getMessage());
+ }
return;
}
if (tcpActive != null) {
@@ -584,42 +663,70 @@
sendRtpItem.setStatus(1);
sendRtpItem.setCallId(callIdHeader.getCallId());
- SIPRequest request = (SIPRequest) evt.getRequest();
sendRtpItem.setFromTag(request.getFromTag());
- SIPResponse response = sendStreamAck(mediaServerItem, serverTransaction, sendRtpItem, platform, evt);
+ SIPResponse response = sendStreamAck(mediaServerItem, request, sendRtpItem, platform, evt);
if (response != null) {
sendRtpItem.setToTag(response.getToTag());
}
-
redisCatchStorage.updateSendRTPSever(sendRtpItem);
} else {
// 涓嶅湪绾� 鎷夎捣
- notifyStreamOnline(evt, serverTransaction,gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
+ notifyStreamOnline(evt, request, gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
}
} else {
// 鍏朵粬骞冲彴鍐呭
- otherWvpPushStream(evt, serverTransaction, gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
+ otherWvpPushStream(evt, request, gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
}
}
+
/**
* 閫氱煡娴佷笂绾�
*/
- private void notifyStreamOnline(RequestEvent evt, ServerTransaction serverTransaction, GbStream gbStream, StreamPushItem streamPushItem, ParentPlatform platform,
+ private void notifyStreamOnline(RequestEvent evt, SIPRequest request, GbStream gbStream, StreamPushItem streamPushItem, ParentPlatform platform,
CallIdHeader callIdHeader, MediaServerItem mediaServerItem,
int port, Boolean tcpActive, boolean mediaTransmissionTCP,
- String channelId, String addressStr, String ssrc, String requesterId) throws InvalidArgumentException, ParseException, SipException {
+ String channelId, String addressStr, String ssrc, String requesterId) {
if ("proxy".equals(gbStream.getStreamType())) {
// TODO 鎺у埗鍚敤浠ヤ娇璁惧涓婄嚎
logger.info("[ app={}, stream={} ]閫氶亾鏈帹娴侊紝鍚敤娴佸悗寮�濮嬫帹娴�", gbStream.getApp(), gbStream.getStream());
- responseAck(serverTransaction, Response.BAD_REQUEST, "channel [" + gbStream.getGbId() + "] offline");
+ // 鐩戝惉娴佷笂绾�
+ HookSubscribeForStreamChange hookSubscribe = HookSubscribeFactory.on_stream_changed(gbStream.getApp(), gbStream.getStream(), true, "rtsp", mediaServerItem.getId());
+ zlmHttpHookSubscribe.addSubscribe(hookSubscribe, (mediaServerItemInUSe, hookParam) -> {
+ OnStreamChangedHookParam streamChangedHookParam = (OnStreamChangedHookParam)hookParam;
+ logger.info("[涓婄骇鐐规挱]鎷夋祦浠ｇ悊宸茬粡灏辩华锛� {}/{}", streamChangedHookParam.getApp(), streamChangedHookParam.getStream());
+ dynamicTask.stop(callIdHeader.getCallId());
+ pushProxyStream(evt, request, gbStream, platform, callIdHeader, mediaServerItem, port, tcpActive,
+ mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
+ });
+ dynamicTask.startDelay(callIdHeader.getCallId(), () -> {
+ logger.info("[ app={}, stream={} ] 绛夊緟鎷夋祦浠ｇ悊娴佽秴鏃�", gbStream.getApp(), gbStream.getStream());
+ zlmHttpHookSubscribe.removeSubscribe(hookSubscribe);
+ }, userSetting.getPlatformPlayTimeout());
+ boolean start = streamProxyService.start(gbStream.getApp(), gbStream.getStream());
+ if (!start) {
+ try {
+ responseAck(request, Response.BUSY_HERE, "channel [" + gbStream.getGbId() + "] offline");
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 閫氶亾鏈帹娴�: {}", e.getMessage());
+ }
+ zlmHttpHookSubscribe.removeSubscribe(hookSubscribe);
+ dynamicTask.stop(callIdHeader.getCallId());
+ }
+
+
} else if ("push".equals(gbStream.getStreamType())) {
if (!platform.isStartOfflinePush()) {
// 骞冲彴璁剧疆涓叧闂簡鎷夎捣绂荤嚎鐨勬帹娴佸垯鐩存帴鍥炲
- responseAck(serverTransaction, Response.TEMPORARILY_UNAVAILABLE, "channel stream not pushing");
+ try {
+ logger.info("[涓婄骇鐐规挱] 澶辫触锛屾帹娴佽澶囨湭鎺ㄦ祦锛宑hannel: {}, app: {}, stream: {}", gbStream.getGbId(), gbStream.getApp(), gbStream.getStream());
+ responseAck(request, Response.TEMPORARILY_UNAVAILABLE, "channel stream not pushing");
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 閫氶亾鏈帹娴�: {}", e.getMessage());
+ }
return;
}
// 鍙戦�乺edis娑堟伅浠ヤ娇璁惧涓婄嚎
@@ -634,13 +741,13 @@
logger.info("[ app={}, stream={} ] 绛夊緟璁惧寮�濮嬫帹娴佽秴鏃�", gbStream.getApp(), gbStream.getStream());
try {
mediaListManager.removedChannelOnlineEventLister(gbStream.getApp(), gbStream.getStream());
- responseAck(serverTransaction, Response.REQUEST_TIMEOUT); // 瓒呮椂
+ responseAck(request, Response.REQUEST_TIMEOUT); // 瓒呮椂
} catch (SipException e) {
- e.printStackTrace();
+ logger.error("鏈鐞嗙殑寮傚父 ", e);
} catch (InvalidArgumentException e) {
- e.printStackTrace();
+ logger.error("鏈鐞嗙殑寮傚父 ", e);
} catch (ParseException e) {
- e.printStackTrace();
+ logger.error("鏈鐞嗙殑寮傚父 ", e);
}
}, userSetting.getPlatformPlayTimeout());
// 娣诲姞鐩戝惉
@@ -651,19 +758,19 @@
mediaListManager.addChannelOnlineEventLister(gbStream.getApp(), gbStream.getStream(), (app, stream, serverId) -> {
dynamicTask.stop(callIdHeader.getCallId());
if (serverId.equals(userSetting.getServerId())) {
- SendRtpItem sendRtpItem = zlmrtpServerFactory.createSendRtpItem(mediaServerItem, addressStr, finalPort, ssrc, requesterId,
- app, stream, channelId, mediaTransmissionTCP);
+ SendRtpItem sendRtpItem = zlmServerFactory.createSendRtpItem(mediaServerItem, addressStr, finalPort, ssrc, requesterId,
+ app, stream, channelId, mediaTransmissionTCP, platform.isRtcp());
if (sendRtpItem == null) {
logger.warn("涓婄骇鐐规椂鍒涘缓sendRTPItem澶辫触锛屽彲鑳芥槸鏈嶅姟鍣ㄧ鍙ｈ祫婧愪笉瓒�");
try {
- responseAck(serverTransaction, Response.BUSY_HERE);
+ responseAck(request, Response.BUSY_HERE);
} catch (SipException e) {
- e.printStackTrace();
+ logger.error("鏈鐞嗙殑寮傚父 ", e);
} catch (InvalidArgumentException e) {
- e.printStackTrace();
+ logger.error("鏈鐞嗙殑寮傚父 ", e);
} catch (ParseException e) {
- e.printStackTrace();
+ logger.error("鏈鐞嗙殑寮傚父 ", e);
}
return;
}
@@ -675,16 +782,15 @@
sendRtpItem.setStatus(1);
sendRtpItem.setCallId(callIdHeader.getCallId());
- SIPRequest request = (SIPRequest) evt.getRequest();
sendRtpItem.setFromTag(request.getFromTag());
- SIPResponse response = sendStreamAck(mediaServerItem, serverTransaction, sendRtpItem, platform, evt);
+ SIPResponse response = sendStreamAck(mediaServerItem, request, sendRtpItem, platform, evt);
if (response != null) {
sendRtpItem.setToTag(response.getToTag());
}
redisCatchStorage.updateSendRTPSever(sendRtpItem);
} else {
// 鍏朵粬骞冲彴鍐呭
- otherWvpPushStream(evt, serverTransaction, gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
+ otherWvpPushStream(evt, request, gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
}
});
@@ -695,7 +801,7 @@
dynamicTask.stop(callIdHeader.getCallId());
mediaListManager.removedChannelOnlineEventLister(gbStream.getApp(), gbStream.getStream());
try {
- responseAck(serverTransaction, Response.TEMPORARILY_UNAVAILABLE, response.getMsg());
+ responseAck(request, Response.TEMPORARILY_UNAVAILABLE, response.getMsg());
} catch (SipException | InvalidArgumentException | ParseException e) {
logger.error("[鍛戒护鍙戦�佸け璐 鍥芥爣绾ц仈 鐐规挱鍥炲: {}", e.getMessage());
}
@@ -707,7 +813,7 @@
/**
* 鏉ヨ嚜鍏朵粬wvp鐨勬帹娴�
*/
- private void otherWvpPushStream(RequestEvent evt, ServerTransaction serverTransaction, GbStream gbStream, StreamPushItem streamPushItem, ParentPlatform platform,
+ private void otherWvpPushStream(RequestEvent evt, SIPRequest request, GbStream gbStream, StreamPushItem streamPushItem, ParentPlatform platform,
CallIdHeader callIdHeader, MediaServerItem mediaServerItem,
int port, Boolean tcpActive, boolean mediaTransmissionTCP,
String channelId, String addressStr, String ssrc, String requesterId) {
@@ -715,18 +821,18 @@
// 鍙戦�乺edis娑堟伅
redisGbPlayMsgListener.sendMsg(streamPushItem.getServerId(), streamPushItem.getMediaServerId(),
streamPushItem.getApp(), streamPushItem.getStream(), addressStr, port, ssrc, requesterId,
- channelId, mediaTransmissionTCP, null, responseSendItemMsg -> {
+ channelId, mediaTransmissionTCP, platform.isRtcp(), null, responseSendItemMsg -> {
SendRtpItem sendRtpItem = responseSendItemMsg.getSendRtpItem();
if (sendRtpItem == null || responseSendItemMsg.getMediaServerItem() == null) {
logger.warn("鏈嶅姟鍣ㄧ鍙ｈ祫婧愪笉瓒�");
try {
- responseAck(serverTransaction, Response.BUSY_HERE);
+ responseAck(request, Response.BUSY_HERE);
} catch (SipException e) {
- e.printStackTrace();
+ logger.error("鏈鐞嗙殑寮傚父 ", e);
} catch (InvalidArgumentException e) {
- e.printStackTrace();
+ logger.error("鏈鐞嗙殑寮傚父 ", e);
} catch (ParseException e) {
- e.printStackTrace();
+ logger.error("鏈鐞嗙殑寮傚父 ", e);
}
return;
}
@@ -739,50 +845,39 @@
sendRtpItem.setStatus(1);
sendRtpItem.setCallId(callIdHeader.getCallId());
- SIPRequest request = (SIPRequest) evt.getRequest();
sendRtpItem.setFromTag(request.getFromTag());
- SIPResponse response = sendStreamAck(responseSendItemMsg.getMediaServerItem(), serverTransaction,sendRtpItem, platform, evt);
+ SIPResponse response = sendStreamAck(responseSendItemMsg.getMediaServerItem(), request, sendRtpItem, platform, evt);
if (response != null) {
sendRtpItem.setToTag(response.getToTag());
}
redisCatchStorage.updateSendRTPSever(sendRtpItem);
}, (wvpResult) -> {
- try {
- // 閿欒
- if (wvpResult.getCode() == RedisGbPlayMsgListener.ERROR_CODE_OFFLINE) {
- // 绂荤嚎
- // 鏌ヨ鏄惁鍦ㄦ湰鏈轰笂绾夸簡
- StreamPushItem currentStreamPushItem = streamPushService.getPush(streamPushItem.getApp(), streamPushItem.getStream());
- if (currentStreamPushItem.isPushIng()) {
- // 鍦ㄧ嚎鐘舵��
- pushStream(evt, serverTransaction, gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
- mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
- } else {
- // 涓嶅湪绾� 鎷夎捣
- notifyStreamOnline(evt, serverTransaction, gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
- mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
- }
+ // 閿欒
+ if (wvpResult.getCode() == RedisGbPlayMsgListener.ERROR_CODE_OFFLINE) {
+ // 绂荤嚎
+ // 鏌ヨ鏄惁鍦ㄦ湰鏈轰笂绾夸簡
+ StreamPushItem currentStreamPushItem = streamPushService.getPush(streamPushItem.getApp(), streamPushItem.getStream());
+ if (currentStreamPushItem.isPushIng()) {
+ // 鍦ㄧ嚎鐘舵��
+ pushStream(evt, request, gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
+ mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
+
+ } else {
+ // 涓嶅湪绾� 鎷夎捣
+ notifyStreamOnline(evt, request, gbStream, streamPushItem, platform, callIdHeader, mediaServerItem, port, tcpActive,
+ mediaTransmissionTCP, channelId, addressStr, ssrc, requesterId);
}
- } catch (InvalidArgumentException | ParseException | SipException e) {
- logger.error("[鍛戒护鍙戦�佸け璐 鍥芥爣绾ц仈 鐐规挱鍥炲: {}", e.getMessage());
}
-
-
try {
- responseAck(serverTransaction, Response.BUSY_HERE);
- } catch (SipException e) {
- e.printStackTrace();
- } catch (InvalidArgumentException e) {
- e.printStackTrace();
- } catch (ParseException e) {
- e.printStackTrace();
+ responseAck(request, Response.BUSY_HERE);
+ } catch (InvalidArgumentException | ParseException | SipException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 鍥芥爣绾ц仈 鐐规挱鍥炲 BUSY_HERE: {}", e.getMessage());
}
- return;
});
}
- public SIPResponse sendStreamAck(MediaServerItem mediaServerItem, ServerTransaction serverTransaction, SendRtpItem sendRtpItem, ParentPlatform platform, RequestEvent evt) {
+ public SIPResponse sendStreamAck(MediaServerItem mediaServerItem, SIPRequest request, SendRtpItem sendRtpItem, ParentPlatform platform, RequestEvent evt) {
StringBuffer content = new StringBuffer(200);
content.append("v=0\r\n");
@@ -790,7 +885,12 @@
content.append("s=Play\r\n");
content.append("c=IN IP4 " + mediaServerItem.getSdpIp() + "\r\n");
content.append("t=0 0\r\n");
- content.append("m=video " + sendRtpItem.getLocalPort() + " RTP/AVP 96\r\n");
+ // 闈炰弗鏍兼ā寮忕鍙ｄ笉缁熶竴, 澧炲姞鍏煎鎬э紝淇敼涓轰竴涓笉涓�0鐨勭鍙�
+ int localPort = sendRtpItem.getLocalPort();
+ if (localPort == 0) {
+ localPort = new Random().nextInt(65535) + 1;
+ }
+ content.append("m=video " + localPort + " RTP/AVP 96\r\n");
content.append("a=sendonly\r\n");
content.append("a=rtpmap:96 PS/90000\r\n");
if (sendRtpItem.isTcp()) {
@@ -805,238 +905,249 @@
content.append("f=\r\n");
try {
- return responseSdpAck(serverTransaction, content.toString(), platform);
- } catch (SipException e) {
- e.printStackTrace();
- } catch (InvalidArgumentException e) {
- e.printStackTrace();
- } catch (ParseException e) {
- e.printStackTrace();
+ return responseSdpAck(request, content.toString(), platform);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("鏈鐞嗙殑寮傚父 ", e);
}
return null;
}
- public void inviteFromDeviceHandle(ServerTransaction serverTransaction, String requesterId, String channelId) throws InvalidArgumentException, ParseException, SipException, SdpException {
+ public void inviteFromDeviceHandle(SIPRequest request, String requesterId, String channelId) {
+
+ String realChannelId = null;
// 闈炰笂绾у钩鍙拌姹傦紝鏌ヨ鏄惁璁惧璇锋眰锛堥�氬父涓烘帴鏀惰闊冲箍鎾殑璁惧锛�
Device device = redisCatchStorage.getDevice(requesterId);
- AudioBroadcastCatch audioBroadcastCatch = audioBroadcastManager.get(requesterId, channelId);
- if (audioBroadcastCatch == null) {
- logger.warn("鏉ヨ嚜璁惧鐨処nvite璇锋眰闈炶闊冲箍鎾紝宸插拷鐣ワ紝requesterId锛� {}/{}", requesterId, channelId);
- responseAck(serverTransaction, Response.FORBIDDEN);
+ // 鍒ゆ柇requesterId鏄澶囪繕鏄�氶亾
+ if (device == null) {
+ device = storager.queryVideoDeviceByChannelId(requesterId);
+ realChannelId = requesterId;
+ }else {
+ realChannelId = channelId;
+ }
+ if (device == null) {
+ // 妫�鏌hannelID鏄惁鍙敤
+ device = redisCatchStorage.getDevice(channelId);
+ if (device == null) {
+ device = storager.queryVideoDeviceByChannelId(channelId);
+ realChannelId = channelId;
+ }
+ }
+
+ if (device == null) {
+ logger.warn("鏉ヨ嚜璁惧鐨処nvite璇锋眰锛屾棤娉曚粠璇锋眰淇℃伅涓‘瀹氭墍灞炶澶囷紝宸插拷鐣ワ紝requesterId锛� {}/{}", requesterId, channelId);
+ try {
+ responseAck(request, Response.FORBIDDEN);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 鏉ヨ嚜璁惧鐨処nvite璇锋眰锛屾棤娉曚粠璇锋眰淇℃伅涓‘瀹氭墍灞炶澶� FORBIDDEN: {}", e.getMessage());
+ }
return;
}
- Request request = serverTransaction.getRequest();
+
+ AudioBroadcastCatch broadcastCatch = audioBroadcastManager.get(device.getDeviceId(), realChannelId);
+ if (broadcastCatch == null) {
+ logger.warn("鏉ヨ嚜璁惧鐨処nvite璇锋眰闈炶闊冲箍鎾紝宸插拷鐣ワ紝requesterId锛� {}/{}", requesterId, channelId);
+ try {
+ responseAck(request, Response.FORBIDDEN);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 鏉ヨ嚜璁惧鐨処nvite璇锋眰闈炶闊冲箍鎾� FORBIDDEN: {}", e.getMessage());
+ }
+ return;
+ }
if (device != null) {
logger.info("鏀跺埌璁惧" + requesterId + "鐨勮闊冲箍鎾璉nvite璇锋眰");
- responseAck(serverTransaction, Response.TRYING);
-
- String contentString = new String(serverTransaction.getRequest().getRawContent());
+ String key = VideoManagerConstants.BROADCAST_WAITE_INVITE + device.getDeviceId() + broadcastCatch.getChannelId();
+ dynamicTask.stop(key);
+ try {
+ responseAck(request, Response.TRYING);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite BAD_REQUEST: {}", e.getMessage());
+ playService.stopAudioBroadcast(device.getDeviceId(), broadcastCatch.getChannelId());
+ return;
+ }
+ String contentString = new String(request.getRawContent());
// jainSip涓嶆敮鎸亂=瀛楁锛� 绉婚櫎绉婚櫎浠ヨВ鏋愩��
- String substring = contentString;
String ssrc = "0000000404";
- int ssrcIndex = contentString.indexOf("y=");
- if (ssrcIndex > 0) {
- substring = contentString.substring(0, ssrcIndex);
- ssrc = contentString.substring(ssrcIndex + 2, ssrcIndex + 12).trim();
- }
- ssrcIndex = substring.indexOf("f=");
- if (ssrcIndex > 0) {
- substring = contentString.substring(0, ssrcIndex);
- }
- SessionDescription sdp = SdpFactory.getInstance().createSessionDescription(substring);
- // 鑾峰彇鏀寔鐨勬牸寮�
- Vector mediaDescriptions = sdp.getMediaDescriptions(true);
+ try {
+ Gb28181Sdp gb28181Sdp = SipUtils.parseSDP(contentString);
+ SessionDescription sdp = gb28181Sdp.getBaseSdb();
+ // 鑾峰彇鏀寔鐨勬牸寮�
+ Vector mediaDescriptions = sdp.getMediaDescriptions(true);
- // 鏌ョ湅鏄惁鏀寔PS 璐熻浇96
- int port = -1;
- boolean mediaTransmissionTCP = false;
- Boolean tcpActive = null;
- for (int i = 0; i < mediaDescriptions.size(); i++) {
- MediaDescription mediaDescription = (MediaDescription)mediaDescriptions.get(i);
- Media media = mediaDescription.getMedia();
+ // 鏌ョ湅鏄惁鏀寔PS 璐熻浇96
+ int port = -1;
+ boolean mediaTransmissionTCP = false;
+ Boolean tcpActive = null;
+ for (int i = 0; i < mediaDescriptions.size(); i++) {
+ MediaDescription mediaDescription = (MediaDescription) mediaDescriptions.get(i);
+ Media media = mediaDescription.getMedia();
- Vector mediaFormats = media.getMediaFormats(false);
- if (mediaFormats.contains("8")) {
- port = media.getMediaPort();
- String protocol = media.getProtocol();
- // 鍖哄垎TCP鍙戞祦杩樻槸udp锛� 褰撳墠榛樿udp
- if ("TCP/RTP/AVP".equals(protocol)) {
- String setup = mediaDescription.getAttribute("setup");
- if (setup != null) {
- mediaTransmissionTCP = true;
- if ("active".equals(setup)) {
- tcpActive = true;
- } else if ("passive".equals(setup)) {
- tcpActive = false;
+ Vector mediaFormats = media.getMediaFormats(false);
+ if (mediaFormats.contains("8")) {
+ port = media.getMediaPort();
+ String protocol = media.getProtocol();
+ // 鍖哄垎TCP鍙戞祦杩樻槸udp锛� 褰撳墠榛樿udp
+ if ("TCP/RTP/AVP".equals(protocol)) {
+ String setup = mediaDescription.getAttribute("setup");
+ if (setup != null) {
+ mediaTransmissionTCP = true;
+ if ("active".equals(setup)) {
+ tcpActive = true;
+ } else if ("passive".equals(setup)) {
+ tcpActive = false;
+ }
}
}
+ break;
}
- break;
}
- }
- if (port == -1) {
- logger.info("涓嶆敮鎸佺殑濯掍綋鏍煎紡锛岃繑鍥�415");
- // 鍥炲涓嶆敮鎸佺殑鏍煎紡
- responseAck(serverTransaction, Response.UNSUPPORTED_MEDIA_TYPE); // 涓嶆敮鎸佺殑鏍煎紡锛屽彂415
- return;
- }
- String addressStr = sdp.getOrigin().getAddress();
- logger.info("璁惧{}璇锋眰璇煶娴侊紝鍦板潃锛歿}:{}锛宻src锛歿}", requesterId, addressStr, port, ssrc);
-
- MediaServerItem mediaServerItem = playService.getNewMediaServerItem(device);
- if (mediaServerItem == null) {
- logger.warn("鏈壘鍒板彲鐢ㄧ殑zlm");
- responseAck(serverTransaction, Response.BUSY_HERE);
- return;
- }
- SendRtpItem sendRtpItem = zlmrtpServerFactory.createSendRtpItem(mediaServerItem, addressStr, port, ssrc, requesterId,
- device.getDeviceId(), audioBroadcastCatch.getChannelId(),
- mediaTransmissionTCP);
- if (sendRtpItem == null) {
- logger.warn("鏈嶅姟鍣ㄧ鍙ｈ祫婧愪笉瓒�");
- responseAck(serverTransaction, Response.BUSY_HERE);
- return;
- }
- sendRtpItem.setTcp(mediaTransmissionTCP);
- if (tcpActive != null) {
- sendRtpItem.setTcpActive(tcpActive);
- }
- String app = "broadcast";
- String stream = device.getDeviceId() + "_" + audioBroadcastCatch.getChannelId();
-
- CallIdHeader callIdHeader = (CallIdHeader) request.getHeader(CallIdHeader.NAME);
- sendRtpItem.setPlayType(InviteStreamType.PLAY);
- sendRtpItem.setCallId(callIdHeader.getCallId());
- sendRtpItem.setPlatformId(requesterId);
- sendRtpItem.setStatus(1);
- sendRtpItem.setApp(app);
- sendRtpItem.setStreamId(stream);
- sendRtpItem.setPt(8);
- sendRtpItem.setUsePs(false);
- sendRtpItem.setOnlyAudio(true);
- redisCatchStorage.updateSendRTPSever(sendRtpItem);
-
- // hook鐩戝惉绛夊緟璁惧鎺ㄦ祦涓婃潵
- // 娣诲姞璁㈤槄
- HookSubscribeForStreamChange subscribeKey = HookSubscribeFactory.on_stream_changed(app, stream, true, "rtsp", mediaServerItem.getId());
-
- String finalSsrc = ssrc;
- // 娴佸凡缁忓瓨鍦ㄦ椂鐩存帴鎺ㄦ祦
- // 璁剧疆绛夊緟鎺ㄦ祦鐨勮秴鏃�; 榛樿20s
- String waiteStreamTimeoutTaskKey = "waite-stream-" + device.getDeviceId() + audioBroadcastCatch.getChannelId();
- dynamicTask.startDelay(waiteStreamTimeoutTaskKey, ()->{
- logger.info("绛夊緟鎺ㄦ祦瓒呮椂: {}/{}", app, stream);
- subscribe.removeSubscribe(subscribeKey);
- playService.stopAudioBroadcast(device.getDeviceId(), audioBroadcastCatch.getChannelId());
- // 鍙戦�乥ye
+ if (port == -1) {
+ logger.info("涓嶆敮鎸佺殑濯掍綋鏍煎紡锛岃繑鍥�415");
+ // 鍥炲涓嶆敮鎸佺殑鏍煎紡
try {
- responseAck(evt, Response.BUSY_HERE);
- } catch (SipException e) {
- throw new RuntimeException(e);
- } catch (InvalidArgumentException e) {
- throw new RuntimeException(e);
- } catch (ParseException e) {
- throw new RuntimeException(e);
+ responseAck(request, Response.UNSUPPORTED_MEDIA_TYPE); // 涓嶆敮鎸佺殑鏍煎紡锛屽彂415
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 涓嶆敮鎸佺殑濯掍綋鏍煎紡: {}", e.getMessage());
+ playService.stopAudioBroadcast(device.getDeviceId(), broadcastCatch.getChannelId());
+ return;
}
- }, 20*1000);
+ return;
+ }
+ String addressStr = sdp.getOrigin().getAddress();
+ logger.info("璁惧{}璇锋眰璇煶娴侊紝鍦板潃锛歿}:{}锛宻src锛歿}, {}", requesterId, addressStr, port, ssrc,
+ mediaTransmissionTCP ? (tcpActive ? "TCP涓诲姩" : "TCP琚姩") : "UDP");
- boolean finalMediaTransmissionTCP = mediaTransmissionTCP;
- subscribe.addSubscribe(subscribeKey,
- (MediaServerItem mediaServerItemInUse, JSONObject json)->{
- logger.info("鏀跺埌璇煶瀵硅鎺ㄦ祦");
- dynamicTask.stop(waiteStreamTimeoutTaskKey);
- MediaItem mediaItem = JSON.toJavaObject(json, MediaItem.class);
- Integer audioCodecId = null;
- if (mediaItem.getTracks() != null && mediaItem.getTracks().size() > 0) {
- for (int i = 0; i < mediaItem.getTracks().size(); i++) {
- MediaItem.MediaTrack mediaTrack = mediaItem.getTracks().get(i);
- if (mediaTrack.getCodecType() == 1) {
- audioCodecId = mediaTrack.getCodecId();
- break;
- }
- }
- }
+ MediaServerItem mediaServerItem = broadcastCatch.getMediaServerItem();
+ if (mediaServerItem == null) {
+ logger.warn("鏈壘鍒拌闊冲枈璇濅娇鐢ㄧ殑zlm");
+ try {
+ responseAck(request, Response.BUSY_HERE);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 鏈壘鍒板彲鐢ㄧ殑zlm: {}", e.getMessage());
+ playService.stopAudioBroadcast(device.getDeviceId(), broadcastCatch.getChannelId());
+ }
+ return;
+ }
+ logger.info("璁惧{}璇锋眰璇煶娴侊紝 鏀舵祦鍦板潃锛歿}:{}锛宻src锛歿}, {}, 瀵硅鏂瑰紡锛歿}", requesterId, addressStr, port, ssrc,
+ mediaTransmissionTCP ? (tcpActive ? "TCP涓诲姩" : "TCP琚姩") : "UDP", sdp.getSessionName().getValue());
+ CallIdHeader callIdHeader = (CallIdHeader) request.getHeader(CallIdHeader.NAME);
- try {
- sendRtpItem.setStatus(2);
- redisCatchStorage.updateSendRTPSever(sendRtpItem);
- StringBuffer content = new StringBuffer(200);
- content.append("v=0\r\n");
- content.append("o="+ config.getId() +" "+ sdp.getOrigin().getSessionId() +" " + sdp.getOrigin().getSessionVersion() + " IN IP4 "+mediaServerItem.getSdpIp()+"\r\n");
- content.append("s=Play\r\n");
- content.append("c=IN IP4 "+mediaServerItem.getSdpIp()+"\r\n");
- content.append("t=0 0\r\n");
- if (audioCodecId == null) {
- if (finalMediaTransmissionTCP) {
- content.append("m=audio "+ sendRtpItem.getLocalPort()+" TCP/RTP/AVP 8\r\n");
- }else {
- content.append("m=audio "+ sendRtpItem.getLocalPort()+" RTP/AVP 8\r\n");
- }
+ SendRtpItem sendRtpItem = zlmServerFactory.createSendRtpItem(mediaServerItem, addressStr, port, ssrc, requesterId,
+ device.getDeviceId(), broadcastCatch.getChannelId(),
+ mediaTransmissionTCP, false);
- content.append("a=rtpmap:8 PCMA/8000\r\n");
- }else {
- if (audioCodecId == 4) {
- if (finalMediaTransmissionTCP) {
- content.append("m=audio "+ sendRtpItem.getLocalPort()+" TCP/RTP/AVP 0\r\n");
- }else {
- content.append("m=audio "+ sendRtpItem.getLocalPort()+" RTP/AVP 0\r\n");
- }
- content.append("a=rtpmap:0 PCMU/8000\r\n");
- }else {
- if (finalMediaTransmissionTCP) {
- content.append("m=audio "+ sendRtpItem.getLocalPort()+" TCP/RTP/AVP 8\r\n");
- }else {
- content.append("m=audio "+ sendRtpItem.getLocalPort()+" RTP/AVP 8\r\n");
- }
- content.append("a=rtpmap:8 PCMA/8000\r\n");
- }
- }
- content.append("a=sendonly\r\n");
- if (sendRtpItem.isTcp()) {
- content.append("a=connection:new\r\n");
- if (!sendRtpItem.isTcpActive()) {
- content.append("a=setup:active\r\n");
- }else {
- content.append("a=setup:passive\r\n");
- }
- }
- content.append("y="+ finalSsrc + "\r\n");
- content.append("f=v/////a/1/8/1\r\n");
+ if (sendRtpItem == null) {
+ logger.warn("鏈嶅姟鍣ㄧ鍙ｈ祫婧愪笉瓒�");
+ try {
+ responseAck(request, Response.BUSY_HERE);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 鏈嶅姟鍣ㄧ鍙ｈ祫婧愪笉瓒�: {}", e.getMessage());
+ playService.stopAudioBroadcast(device.getDeviceId(), broadcastCatch.getChannelId());
+ return;
+ }
+ return;
+ }
- ParentPlatform parentPlatform = new ParentPlatform();
- parentPlatform.setServerIP(device.getIp());
- parentPlatform.setServerPort(device.getPort());
- parentPlatform.setServerGBId(device.getDeviceId());
- responseSdpAck(serverTransaction, content.toString(), parentPlatform);
- Dialog dialog = evt.getDialog();
- audioBroadcastCatch.setDialog((SIPDialog) dialog);
- audioBroadcastCatch.setRequest((SIPRequest) request);
- audioBroadcastManager.update(audioBroadcastCatch);
- } catch (SipException | InvalidArgumentException | ParseException | SdpParseException e) {
- logger.error("[鍛戒护鍙戦�佸け璐 璇煶瀵硅: {}", e.getMessage());
- }
- });
-// }
- String key = DeferredResultHolder.CALLBACK_CMD_BROADCAST + device.getDeviceId();
- WVPResult<AudioBroadcastResult> wvpResult = new WVPResult<>();
- wvpResult.setCode(0);
- wvpResult.setMsg("success");
- AudioBroadcastResult audioBroadcastResult = new AudioBroadcastResult();
- audioBroadcastResult.setApp(app);
- audioBroadcastResult.setStream(stream);
- audioBroadcastResult.setStreamInfo(mediaService.getStreamInfoByAppAndStream(mediaServerItem, app, stream, null, null, null,false));
- audioBroadcastResult.setCodec("G.711");
- wvpResult.setData(audioBroadcastResult);
- RequestMessage requestMessage = new RequestMessage();
- requestMessage.setKey(key);
- requestMessage.setData(wvpResult);
- resultHolder.invokeAllResult(requestMessage);
+ sendRtpItem.setPlayType(InviteStreamType.BROADCAST);
+ sendRtpItem.setCallId(callIdHeader.getCallId());
+ sendRtpItem.setPlatformId(requesterId);
+ sendRtpItem.setStatus(1);
+ sendRtpItem.setApp(broadcastCatch.getApp());
+ sendRtpItem.setStream(broadcastCatch.getStream());
+ sendRtpItem.setPt(8);
+ sendRtpItem.setUsePs(false);
+ sendRtpItem.setRtcp(false);
+ sendRtpItem.setOnlyAudio(true);
+ sendRtpItem.setTcp(mediaTransmissionTCP);
+ if (tcpActive != null) {
+ sendRtpItem.setTcpActive(tcpActive);
+ }
+
+ redisCatchStorage.updateSendRTPSever(sendRtpItem);
+
+ Boolean streamReady = zlmServerFactory.isStreamReady(mediaServerItem, broadcastCatch.getApp(), broadcastCatch.getStream());
+ if (streamReady) {
+ sendOk(device, sendRtpItem, sdp, request, mediaServerItem, mediaTransmissionTCP, ssrc);
+ } else {
+ logger.warn("[璇煶閫氳瘽]锛� 鏈彂鐜板緟鎺ㄩ�佺殑娴�,app={},stream={}", broadcastCatch.getApp(), broadcastCatch.getStream());
+ try {
+ responseAck(request, Response.GONE);
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 璇煶閫氳瘽 鍥炲410澶辫触锛� {}", e.getMessage());
+ return;
+ }
+ playService.stopAudioBroadcast(device.getDeviceId(), broadcastCatch.getChannelId());
+ }
+ } catch (SdpException e) {
+ logger.error("[SDP瑙ｆ瀽寮傚父]", e);
+ playService.stopAudioBroadcast(device.getDeviceId(), broadcastCatch.getChannelId());
+ }
} else {
logger.warn("鏉ヨ嚜鏃犳晥璁惧/骞冲彴鐨勮姹�");
- responseAck(serverTransaction, Response.BAD_REQUEST);
+ try {
+ responseAck(request, Response.BAD_REQUEST);
+ ; // 涓嶆敮鎸佺殑鏍煎紡锛屽彂415
+ } catch (SipException | InvalidArgumentException | ParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 invite 鏉ヨ嚜鏃犳晥璁惧/骞冲彴鐨勮姹傦紝 {}", e.getMessage());
+ }
}
}
+
+ SIPResponse sendOk(Device device, SendRtpItem sendRtpItem, SessionDescription sdp, SIPRequest request, MediaServerItem mediaServerItem, boolean mediaTransmissionTCP, String ssrc) {
+ SIPResponse sipResponse = null;
+ try {
+ sendRtpItem.setStatus(2);
+ redisCatchStorage.updateSendRTPSever(sendRtpItem);
+ StringBuffer content = new StringBuffer(200);
+ content.append("v=0\r\n");
+ content.append("o=" + config.getId() + " " + sdp.getOrigin().getSessionId() + " " + sdp.getOrigin().getSessionVersion() + " IN IP4 " + mediaServerItem.getSdpIp() + "\r\n");
+ content.append("s=Play\r\n");
+ content.append("c=IN IP4 " + mediaServerItem.getSdpIp() + "\r\n");
+ content.append("t=0 0\r\n");
+
+ if (mediaTransmissionTCP) {
+ content.append("m=audio " + sendRtpItem.getLocalPort() + " TCP/RTP/AVP 8\r\n");
+ } else {
+ content.append("m=audio " + sendRtpItem.getLocalPort() + " RTP/AVP 8\r\n");
+ }
+
+ content.append("a=rtpmap:8 PCMA/8000/1\r\n");
+
+ content.append("a=sendonly\r\n");
+ if (sendRtpItem.isTcp()) {
+ content.append("a=connection:new\r\n");
+ if (!sendRtpItem.isTcpActive()) {
+ content.append("a=setup:active\r\n");
+ } else {
+ content.append("a=setup:passive\r\n");
+ }
+ }
+ content.append("y=" + ssrc + "\r\n");
+ content.append("f=v/////a/1/8/1\r\n");
+
+ ParentPlatform parentPlatform = new ParentPlatform();
+ parentPlatform.setServerIP(device.getIp());
+ parentPlatform.setServerPort(device.getPort());
+ parentPlatform.setServerGBId(device.getDeviceId());
+
+ sipResponse = responseSdpAck(request, content.toString(), parentPlatform);
+
+ AudioBroadcastCatch audioBroadcastCatch = audioBroadcastManager.get(device.getDeviceId(), sendRtpItem.getChannelId());
+
+ audioBroadcastCatch.setStatus(AudioBroadcastCatchStatus.Ok);
+ audioBroadcastCatch.setSipTransactionInfoByRequset(sipResponse);
+ audioBroadcastManager.update(audioBroadcastCatch);
+
+ // 寮�鍚彂娴侊紝澶у崕鍦ㄦ敹鍒�200OK鍚庡氨浼氬紑濮嬪缓绔嬭繛鎺�
+ if (!device.isBroadcastPushAfterAck()) {
+ playService.startPushStream(sendRtpItem, sipResponse, parentPlatform, request.getCallIdHeader());
+ }
+
+ } catch (SipException | InvalidArgumentException | ParseException | SdpParseException e) {
+ logger.error("[鍛戒护鍙戦�佸け璐 璇煶鍠婅瘽 鍥炲200OK锛圫DP锛�: {}", e.getMessage());
+ }
+ return sipResponse;
+ }
}
--
Gitblit v1.8.0