/** {@inheritDoc} */
public synchronized Result createConference(String creator, String mucRoomName) {
Conference conference = conferenceMap.get(mucRoomName);
if (conference == null) {
// Create new conference
try {
ApiResult result = api.createNewConference(creator, mucRoomName);
if (result.getError() == null) {
conference = result.getConference();
conferenceMap.put(mucRoomName, conference);
} else if (result.getStatusCode() == 409 && result.getError().getConflictId() != null) {
Number conflictId = result.getError().getConflictId();
// Conference already exists(check if we have it locally)
conference = findConferenceForId(conflictId);
logger.info("Conference '" + mucRoomName + "' already " + "allocated, id: " + conflictId);
// do GET conflict conference
if (conference == null) {
ApiResult getResult = api.getConference(conflictId);
if (getResult.getConference() != null) {
conference = getResult.getConference();
// Fill full room name as it is not transferred
// over REST API
conference.setMucRoomName(mucRoomName);
conferenceMap.put(mucRoomName, conference);
} else {
logger.error("API error: " + result);
return new Result(RESULT_INTERNAL_ERROR, result.getError().getMessage());
}
}
} else {
// Other error
logger.error("API error: " + result);
return new Result(RESULT_INTERNAL_ERROR, result.getError().getMessage());
}
} catch (FaultTolerantRESTRequest.RetryExhaustedException e) {
logger.error(e, e);
return new Result(RESULT_INTERNAL_ERROR, e.getMessage());
} catch (UnsupportedEncodingException e) {
logger.error(e, e);
return new Result(RESULT_INTERNAL_ERROR, e.getMessage());
}
}
// Verify owner == creator
if (creator.equals(conference.getOwner())) {
return new Result(RESULT_OK);
} else {
logger.error(
"Room " + mucRoomName + ", conflict : " + creator + " != " + conference.getOwner());
return new Result(RESULT_CONFLICT);
}
}
/**
* Returns the sequence number to use for a specific RTX packet, which is based on the packet's
* original sequence number.
*
* <p>Because we terminate the RTX format, and with simulcast we might translate RTX packets from
* multiple SSRCs into the same SSRC, we keep count of the RTX packets (and their sequence
* numbers) which we sent for each SSRC.
*
* @param ssrc the SSRC of the RTX stream for the packet.
* @param defaultSeq the default sequence number to use in case we don't (yet) have any
* information about <tt>ssrc</tt>.
* @return the sequence number which should be used for the next RTX packet sent using SSRC
* <tt>ssrc</tt>.
*/
private int getNextRtxSequenceNumber(long ssrc, int defaultSeq) {
Integer seq;
synchronized (rtxSequenceNumbers) {
seq = rtxSequenceNumbers.get(ssrc);
if (seq == null) seq = defaultSeq;
else seq++;
rtxSequenceNumbers.put(ssrc, seq);
}
return seq;
}
/**
* Returns the sequence number to use for a specific RTX packet, which is based on the packet's
* original sequence number.
*
* <p>Because we terminate the RTX format, and with simulcast we might translate RTX packets from
* multiple SSRCs into the same SSRC, we keep count of the RTX packets (and their sequence
* numbers) which we sent for each SSRC.
*
* @param ssrc the SSRC of the RTX stream for the packet.
* @return the sequence number which should be used for the next RTX packet sent using SSRC
* <tt>ssrc</tt>.
*/
private int getNextRtxSequenceNumber(long ssrc) {
Integer seq;
synchronized (rtxSequenceNumbers) {
seq = rtxSequenceNumbers.get(ssrc);
if (seq == null) seq = new Random().nextInt(0xffff);
else seq++;
rtxSequenceNumbers.put(ssrc, seq);
}
return seq;
}
/**
* Returns the <tt>SSRCDesc</tt> instance mapped to the SSRC <tt>ssrc</tt>. If no instance is
* mapped to <tt>ssrc</tt>, create one and inserts it in the map. Always returns non-null.
*
* @param ssrc the ssrc to get the <tt>SSRCDesc</tt> for.
* @return the <tt>SSRCDesc</tt> instance mapped to the SSRC <tt>ssrc</tt>.
*/
private SSRCDesc getSSRCDesc(long ssrc) {
SSRCDesc ssrcDesc = ssrcs.get(ssrc);
if (ssrcDesc == null) {
synchronized (ssrcs) {
ssrcDesc = ssrcs.get(ssrc);
if (ssrcDesc == null) {
ssrcDesc = new SSRCDesc();
ssrcs.put(ssrc, ssrcDesc);
}
}
}
return ssrcDesc;
}
/**
* Returns the <tt>Endpoint</tt> with id <tt>endpointId</tt>. Creates an <tt>Endpoint</tt> if
* necessary. Always returns non-null.
*
* @param endpointId the string identifying the endpoint.
* @return the <tt>Endpoint</tt> with id <tt>endpointId</tt>. Creates an <tt>Endpoint</tt> if
* necessary.
*/
private Endpoint getEndpoint(String endpointId) {
Endpoint endpoint = endpoints.get(endpointId);
if (endpoint == null) {
synchronized (endpoints) {
endpoint = endpoints.get(endpointId);
if (endpoint == null) {
endpoint = new Endpoint();
endpoints.put(endpointId, endpoint);
}
}
}
return endpoint;
}
/**
* Makes sure that conference is allocated for given <tt>room</tt>.
*
* @param room name of the MUC room of Jitsi Meet conference.
* @param properties configuration properties, see {@link JitsiMeetConfig} for the list of valid
* properties.
* @throws Exception if any error occurs.
*/
private void createConference(String room, Map<String, String> properties) throws Exception {
JitsiMeetConfig config = new JitsiMeetConfig(properties);
JitsiMeetConference conference =
new JitsiMeetConference(room, focusUserName, protocolProviderHandler, this, config);
conferences.put(room, conference);
StringBuilder options = new StringBuilder();
for (Map.Entry<String, String> option : properties.entrySet()) {
options.append("\n ").append(option.getKey()).append(": ").append(option.getValue());
}
logger.info(
"Created new focus for "
+ room
+ "@"
+ focusUserDomain
+ " conferences count: "
+ conferences.size()
+ " options:"
+ options.toString());
// Send focus created event
EventAdmin eventAdmin = FocusBundleActivator.getEventAdmin();
if (eventAdmin != null) {
eventAdmin.sendEvent(EventFactory.focusCreated(conference.getId(), conference.getRoomName()));
}
try {
conference.start();
} catch (Exception e) {
logger.info("Exception while trying to start the conference", e);
// stop() method is called by the conference automatically in order
// to not release the lock on JitsiMeetConference instance and avoid
// a deadlock. It may happen when this thread is about to call
// conference.stop() and another thread has entered the method
// before us. That other thread will try to call
// FocusManager.conferenceEnded, but we're still holding the lock
// on FocusManager instance.
// conference.stop();
throw e;
}
}
/**
* Makes sure that conference is allocated for given <tt>room</tt>.
*
* @param room name of the MUC room of Jitsi Meet conference.
* @param properties configuration properties, see {@link JitsiMeetConfig} for the list of valid
* properties.
* @throws Exception if any error occurs.
*/
private void createConference(String room, Map<String, String> properties) throws Exception {
JitsiMeetConfig config = new JitsiMeetConfig(properties);
JitsiMeetConference conference =
new JitsiMeetConference(room, focusUserName, protocolProviderHandler, this, config);
conferences.put(room, conference);
StringBuilder options = new StringBuilder();
for (Map.Entry<String, String> option : properties.entrySet()) {
options.append("\n ").append(option.getKey()).append(": ").append(option.getValue());
}
logger.info(
"Created new focus for "
+ room
+ "@"
+ focusUserDomain
+ " conferences count: "
+ conferences.size()
+ " options:"
+ options.toString());
// Send focus created event
EventAdmin eventAdmin = FocusBundleActivator.getEventAdmin();
if (eventAdmin != null) {
eventAdmin.sendEvent(EventFactory.focusCreated(conference.getId(), conference.getRoomName()));
}
try {
conference.start();
} catch (Exception e) {
logger.info("Exception while trying to start the conference", e);
conference.stop();
throw e;
}
}
/**
* Opens new WebRTC data channel using specified parameters.
*
* @param type channel type as defined in control protocol description. Use 0 for "reliable".
* @param prio channel priority. The higher the number, the lower the priority.
* @param reliab Reliability Parameter<br>
* This field is ignored if a reliable channel is used. If a partial reliable channel with
* limited number of retransmissions is used, this field specifies the number of
* retransmissions. If a partial reliable channel with limited lifetime is used, this field
* specifies the maximum lifetime in milliseconds. The following table summarizes this:<br>
* </br>
* <p>+------------------------------------------------+------------------+ | Channel Type |
* Reliability | | | Parameter |
* +------------------------------------------------+------------------+ |
* DATA_CHANNEL_RELIABLE | Ignored | | DATA_CHANNEL_RELIABLE_UNORDERED | Ignored | |
* DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT | Number of RTX | |
* DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT_UNORDERED | Number of RTX | |
* DATA_CHANNEL_PARTIAL_RELIABLE_TIMED | Lifetime in ms | |
* DATA_CHANNEL_PARTIAL_RELIABLE_TIMED_UNORDERED | Lifetime in ms |
* +------------------------------------------------+------------------+
* @param sid SCTP stream id that will be used by new channel (it must not be already used).
* @param label text label for the channel.
* @return new instance of <tt>WebRtcDataStream</tt> that represents opened WebRTC data channel.
* @throws IOException if IO error occurs.
*/
public synchronized WebRtcDataStream openChannel(
int type, int prio, long reliab, int sid, String label) throws IOException {
if (channels.containsKey(sid)) {
throw new IOException("Channel on sid: " + sid + " already exists");
}
// Label Length & Label
byte[] labelBytes;
int labelByteLength;
if (label == null) {
labelBytes = null;
labelByteLength = 0;
} else {
labelBytes = label.getBytes("UTF-8");
labelByteLength = labelBytes.length;
if (labelByteLength > 0xFFFF) labelByteLength = 0xFFFF;
}
// Protocol Length & Protocol
String protocol = WEBRTC_DATA_CHANNEL_PROTOCOL;
byte[] protocolBytes;
int protocolByteLength;
if (protocol == null) {
protocolBytes = null;
protocolByteLength = 0;
} else {
protocolBytes = protocol.getBytes("UTF-8");
protocolByteLength = protocolBytes.length;
if (protocolByteLength > 0xFFFF) protocolByteLength = 0xFFFF;
}
ByteBuffer packet = ByteBuffer.allocate(12 + labelByteLength + protocolByteLength);
// Message open new channel on current sid
// Message Type
packet.put((byte) MSG_OPEN_CHANNEL);
// Channel Type
packet.put((byte) type);
// Priority
packet.putShort((short) prio);
// Reliability Parameter
packet.putInt((int) reliab);
// Label Length
packet.putShort((short) labelByteLength);
// Protocol Length
packet.putShort((short) protocolByteLength);
// Label
if (labelByteLength != 0) {
packet.put(labelBytes, 0, labelByteLength);
}
// Protocol
if (protocolByteLength != 0) {
packet.put(protocolBytes, 0, protocolByteLength);
}
int sentCount = sctpSocket.send(packet.array(), true, sid, WEB_RTC_PPID_CTRL);
if (sentCount != packet.capacity()) {
throw new IOException("Failed to open new chanel on sid: " + sid);
}
WebRtcDataStream channel = new WebRtcDataStream(sctpSocket, sid, label, false);
channels.put(sid, channel);
return channel;
}
/**
* Handles control packet.
*
* @param data raw packet data that arrived on control PPID.
* @param sid SCTP stream id on which the data has arrived.
*/
private synchronized void onCtrlPacket(byte[] data, int sid) throws IOException {
ByteBuffer buffer = ByteBuffer.wrap(data);
int messageType = /* 1 byte unsigned integer */ 0xFF & buffer.get();
if (messageType == MSG_CHANNEL_ACK) {
if (logger.isDebugEnabled()) {
logger.debug(getEndpoint().getID() + " ACK received SID: " + sid);
}
// Open channel ACK
WebRtcDataStream channel = channels.get(sid);
if (channel != null) {
// Ack check prevents from firing multiple notifications
// if we get more than one ACKs (by mistake/bug).
if (!channel.isAcknowledged()) {
channel.ackReceived();
notifyChannelOpened(channel);
} else {
logger.warn("Redundant ACK received for SID: " + sid);
}
} else {
logger.error("No channel exists on sid: " + sid);
}
} else if (messageType == MSG_OPEN_CHANNEL) {
int channelType = /* 1 byte unsigned integer */ 0xFF & buffer.get();
int priority = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort();
long reliability = /* 4 bytes unsigned integer */ 0xFFFFFFFFL & buffer.getInt();
int labelLength = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort();
int protocolLength = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort();
String label;
String protocol;
if (labelLength == 0) {
label = "";
} else {
byte[] labelBytes = new byte[labelLength];
buffer.get(labelBytes);
label = new String(labelBytes, "UTF-8");
}
if (protocolLength == 0) {
protocol = "";
} else {
byte[] protocolBytes = new byte[protocolLength];
buffer.get(protocolBytes);
protocol = new String(protocolBytes, "UTF-8");
}
if (logger.isDebugEnabled()) {
logger.debug(
"!!! "
+ getEndpoint().getID()
+ " data channel open request on SID: "
+ sid
+ " type: "
+ channelType
+ " prio: "
+ priority
+ " reliab: "
+ reliability
+ " label: "
+ label
+ " proto: "
+ protocol);
}
if (channels.containsKey(sid)) {
logger.error("Channel on sid: " + sid + " already exists");
}
WebRtcDataStream newChannel = new WebRtcDataStream(sctpSocket, sid, label, true);
channels.put(sid, newChannel);
sendOpenChannelAck(sid);
notifyChannelOpened(newChannel);
} else {
logger.error("Unexpected ctrl msg type: " + messageType);
}
}
/**
* Maybe send a data channel command to the associated <tt>Endpoint</tt> to make it start
* streaming its hq stream, if it's being watched by some receiver.
*/
public void maybeSendStartHighQualityStreamCommand() {
if (nativeSimulcast || !hasLayers()) {
// In native simulcast the client adjusts its layers autonomously so
// we don't need (nor we can) to control it with data channel
// messages.
return;
}
Endpoint newEndpoint = getSimulcastEngine().getVideoChannel().getEndpoint();
SimulcastLayer[] newSimulcastLayers = getSimulcastLayers();
SctpConnection sctpConnection;
if (newSimulcastLayers == null
|| newSimulcastLayers.length <= 1
/* newEndpoint != null is implied */
|| (sctpConnection = newEndpoint.getSctpConnection()) == null
|| !sctpConnection.isReady()
|| sctpConnection.isExpired()) {
return;
}
// we have a new endpoint and it has an SCTP connection that is
// ready and not expired. if somebody else is watching the new
// endpoint, start its hq stream.
boolean startHighQualityStream = false;
for (Endpoint e :
getSimulcastEngine().getVideoChannel().getContent().getConference().getEndpoints()) {
// TODO(gp) need some synchronization here. What if the
// selected endpoint changes while we're in the loop?
if (e == newEndpoint) continue;
Endpoint eSelectedEndpoint = e.getEffectivelySelectedEndpoint();
if (newEndpoint == eSelectedEndpoint) {
// somebody is watching the new endpoint or somebody has not
// yet signaled its selected endpoint to the bridge, start
// the hq stream.
if (logger.isDebugEnabled()) {
Map<String, Object> map = new HashMap<String, Object>(3);
map.put("e", e);
map.put("newEndpoint", newEndpoint);
map.put("maybe", eSelectedEndpoint == null ? "(maybe) " : "");
StringCompiler sc =
new StringCompiler(map).c("{e.id} is {maybe} watching {newEndpoint.id}.");
logDebug(sc.toString().replaceAll("\\s+", " "));
}
startHighQualityStream = true;
break;
}
}
if (startHighQualityStream) {
// TODO(gp) this assumes only a single hq stream.
logDebug(
getSimulcastEngine().getVideoChannel().getEndpoint().getID()
+ " notifies "
+ newEndpoint.getID()
+ " to start its HQ stream.");
SimulcastLayer hqLayer = newSimulcastLayers[newSimulcastLayers.length - 1];
;
StartSimulcastLayerCommand command = new StartSimulcastLayerCommand(hqLayer);
String json = mapper.toJson(command);
try {
newEndpoint.sendMessageOnDataChannel(json);
} catch (IOException e) {
logError(newEndpoint.getID() + " failed to send message on data channel.", e);
}
}
}
/**
* Inspect an <tt>RTCPCompoundPacket</tt> and build-up the state for future estimations.
*
* @param pkt
*/
public void apply(RTCPCompoundPacket pkt) {
if (pkt == null || pkt.packets == null || pkt.packets.length == 0) {
return;
}
for (RTCPPacket rtcpPacket : pkt.packets) {
switch (rtcpPacket.type) {
case RTCPPacket.SR:
RTCPSRPacket srPacket = (RTCPSRPacket) rtcpPacket;
// The media sender SSRC.
int ssrc = srPacket.ssrc;
// Convert 64-bit NTP timestamp to Java standard time.
// Note that java time (milliseconds) by definition has
// less precision then NTP time (picoseconds) so
// converting NTP timestamp to java time and back to NTP
// timestamp loses precision. For example, Tue, Dec 17
// 2002 09:07:24.810 EST is represented by a single
// Java-based time value of f22cd1fc8a, but its NTP
// equivalent are all values ranging from
// c1a9ae1c.cf5c28f5 to c1a9ae1c.cf9db22c.
// Use round-off on fractional part to preserve going to
// lower precision
long fraction = Math.round(1000D * srPacket.ntptimestamplsw / 0x100000000L);
/*
* If the most significant bit (MSB) on the seconds
* field is set we use a different time base. The
* following text is a quote from RFC-2030 (SNTP v4):
*
* If bit 0 is set, the UTC time is in the range
* 1968-2036 and UTC time is reckoned from 0h 0m 0s UTC
* on 1 January 1900. If bit 0 is not set, the time is
* in the range 2036-2104 and UTC time is reckoned from
* 6h 28m 16s UTC on 7 February 2036.
*/
long msb = srPacket.ntptimestampmsw & 0x80000000L;
long remoteTime =
(msb == 0)
// use base: 7-Feb-2036 @ 06:28:16 UTC
? msb0baseTime + (srPacket.ntptimestampmsw * 1000) + fraction
// use base: 1-Jan-1900 @ 01:00:00 UTC
: msb1baseTime + (srPacket.ntptimestampmsw * 1000) + fraction;
// Estimate the clock rate of the sender.
int frequencyHz = -1;
if (receivedClocks.containsKey(ssrc)) {
// Calculate the clock rate.
ReceivedRemoteClock oldStats = receivedClocks.get(ssrc);
RemoteClock oldRemoteClock = oldStats.getRemoteClock();
frequencyHz =
Math.round(
(float)
(((int) srPacket.rtptimestamp - oldRemoteClock.getRtpTimestamp())
& 0xffffffffl)
/ (remoteTime - oldRemoteClock.getRemoteTime()));
}
// Replace whatever was in there before.
receivedClocks.put(
ssrc,
new ReceivedRemoteClock(
ssrc, remoteTime, (int) srPacket.rtptimestamp, frequencyHz));
break;
case RTCPPacket.SDES:
break;
}
}
}
