/** {@inheritDoc} */
@Override
public RawPacket transform(RawPacket pkt) {
if (pkt == null) {
return pkt;
}
RTCPCompoundPacket inPacket;
try {
inPacket =
(RTCPCompoundPacket)
parser.parse(pkt.getBuffer(), pkt.getOffset(), pkt.getLength());
} catch (BadFormatException e) {
logger.warn("Failed to terminate an RTCP packet. " + "Dropping packet.");
return null;
}
// Update our RTCP stats map (timestamps). This operation is
// read-only.
remoteClockEstimator.apply(inPacket);
cnameRegistry.update(inPacket);
// Remove SRs and RRs from the RTCP packet.
pkt = feedbackGateway.gateway(inPacket);
return pkt;
}
/**
* Pools the specified <tt>RawPacket</tt> in order to avoid future allocations and to reduce the
* effects of garbage collection.
*
* @param pkt the <tt>RawPacket</tt> to be offered to {@link #rawPacketPool}
*/
private void poolRawPacket(RawPacket pkt) {
pkt.setBuffer(null);
pkt.setFlags(0);
pkt.setLength(0);
pkt.setOffset(0);
rawPacketPool.offer(pkt);
}
/**
* Creates a new <tt>RawPacket</tt> from a specific <tt>DatagramPacket</tt> in order to have this
* instance receive its packet data through its {@link #read(byte[], int, int)} method. Returns an
* array of <tt>RawPacket</tt> with the created packet as its first element (and <tt>null</tt> for
* the other elements).
*
* <p>Allows extenders to intercept the packet data and possibly filter and/or modify it.
*
* @param datagramPacket the <tt>DatagramPacket</tt> containing the packet data
* @return an array of <tt>RawPacket</tt> containing the <tt>RawPacket</tt> which contains the
* packet data of the specified <tt>DatagramPacket</tt> as its first element.
*/
protected RawPacket[] createRawPacket(DatagramPacket datagramPacket) {
RawPacket[] pkts = rawPacketArrayPool.poll();
if (pkts == null) pkts = new RawPacket[1];
RawPacket pkt = rawPacketPool.poll();
if (pkt == null) pkt = new RawPacket();
pkt.setBuffer(datagramPacket.getData());
pkt.setFlags(0);
pkt.setLength(datagramPacket.getLength());
pkt.setOffset(datagramPacket.getOffset());
pkts[0] = pkt;
return pkts;
}
/**
* Updates this <tt>RTPStatsMap</tt> with information it gets from the <tt>RawPacket</tt>.
*
* @param pkt the <tt>RawPacket</tt> that is being transmitted.
*/
public void apply(RawPacket pkt) {
int ssrc = pkt.getSSRC();
if (this.containsKey(ssrc)) {
RTPStatsEntry oldRtpStatsEntry = this.get(ssrc);
// Replace whatever was in there before. A feature of the two's
// complement encoding (which is used by Java integers) is that
// the bitwise results for add, subtract, and multiply are the
// same if both inputs are interpreted as signed values or both
// inputs are interpreted as unsigned values. (Other encodings
// like one's complement and signed magnitude don't have this
// properly.)
this.put(
ssrc,
new RTPStatsEntry(
ssrc,
oldRtpStatsEntry.getBytesSent()
+ pkt.getLength()
- pkt.getHeaderLength()
- pkt.getPaddingSize(),
oldRtpStatsEntry.getPacketsSent() + 1));
} else {
// Add a new <tt>RTPStatsEntry</tt> in this map.
this.put(
ssrc,
new RTPStatsEntry(
ssrc, pkt.getLength() - pkt.getHeaderLength() - pkt.getPaddingSize(), 1));
}
}
/**
* Copies the content of the most recently received packet into <tt>data</tt>.
*
* @param buffer an optional <tt>Buffer</tt> instance associated with the specified <tt>data</tt>,
* <tt>offset</tt> and <tt>length</tt> and provided to the method in case the implementation
* would like to provide additional <tt>Buffer</tt> properties such as <tt>flags</tt>
* @param data the <tt>byte[]</tt> that we'd like to copy the content of the packet to.
* @param offset the position where we are supposed to start writing in <tt>data</tt>.
* @param length the number of <tt>byte</tt>s available for writing in <tt>data</tt>.
* @return the number of bytes read
* @throws IOException if <tt>length</tt> is less than the size of the packet.
*/
protected int read(Buffer buffer, byte[] data, int offset, int length) throws IOException {
if (data == null) throw new NullPointerException("data");
if (ioError) return -1;
RawPacket pkt;
synchronized (pktSyncRoot) {
pkt = this.pkt;
this.pkt = null;
}
int pktLength;
if (pkt == null) {
pktLength = 0;
} else {
// By default, pkt will be returned to the pool after it was read.
boolean poolPkt = true;
try {
pktLength = pkt.getLength();
if (length < pktLength) {
/*
* If pkt is still the latest RawPacket made available to
* reading, reinstate it for the next invocation of read;
* otherwise, return it to the pool.
*/
poolPkt = false;
throw new IOException("Input buffer not big enough for " + pktLength);
} else {
byte[] pktBuffer = pkt.getBuffer();
if (pktBuffer == null) {
throw new NullPointerException(
"pkt.buffer null, pkt.length " + pktLength + ", pkt.offset " + pkt.getOffset());
} else {
System.arraycopy(pkt.getBuffer(), pkt.getOffset(), data, offset, pktLength);
if (buffer != null) buffer.setFlags(pkt.getFlags());
}
}
} finally {
if (!poolPkt) {
synchronized (pktSyncRoot) {
if (this.pkt == null) this.pkt = pkt;
else poolPkt = true;
}
}
if (poolPkt) {
// Return pkt to the pool because it was successfully read.
poolRawPacket(pkt);
}
}
}
return pktLength;
}
private void runOnDtlsTransport(StreamConnector connector) throws IOException {
DtlsControlImpl dtlsControl = (DtlsControlImpl) getTransportManager().getDtlsControl(this);
DtlsTransformEngine engine = dtlsControl.getTransformEngine();
final DtlsPacketTransformer transformer = (DtlsPacketTransformer) engine.getRTPTransformer();
byte[] receiveBuffer = new byte[SCTP_BUFFER_SIZE];
if (LOG_SCTP_PACKETS) {
System.setProperty(
ConfigurationService.PNAME_SC_HOME_DIR_LOCATION, System.getProperty("java.io.tmpdir"));
System.setProperty(
ConfigurationService.PNAME_SC_HOME_DIR_NAME, SctpConnection.class.getName());
}
synchronized (this) {
// FIXME local SCTP port is hardcoded in bridge offer SDP (Jitsi
// Meet)
sctpSocket = Sctp.createSocket(5000);
assocIsUp = false;
acceptedIncomingConnection = false;
}
// Implement output network link for SCTP stack on DTLS transport
sctpSocket.setLink(
new NetworkLink() {
@Override
public void onConnOut(SctpSocket s, byte[] packet) throws IOException {
if (LOG_SCTP_PACKETS) {
LibJitsi.getPacketLoggingService()
.logPacket(
PacketLoggingService.ProtocolName.ICE4J,
new byte[] {0, 0, 0, (byte) debugId},
5000,
new byte[] {0, 0, 0, (byte) (debugId + 1)},
remoteSctpPort,
PacketLoggingService.TransportName.UDP,
true,
packet);
}
// Send through DTLS transport
transformer.sendApplicationData(packet, 0, packet.length);
}
});
if (logger.isDebugEnabled()) {
logger.debug("Connecting SCTP to port: " + remoteSctpPort + " to " + getEndpoint().getID());
}
sctpSocket.setNotificationListener(this);
sctpSocket.listen();
// FIXME manage threads
threadPool.execute(
new Runnable() {
@Override
public void run() {
SctpSocket sctpSocket = null;
try {
// sctpSocket is set to null on close
sctpSocket = SctpConnection.this.sctpSocket;
while (sctpSocket != null) {
if (sctpSocket.accept()) {
acceptedIncomingConnection = true;
break;
}
Thread.sleep(100);
sctpSocket = SctpConnection.this.sctpSocket;
}
if (isReady()) {
notifySctpConnectionReady();
}
} catch (Exception e) {
logger.error("Error accepting SCTP connection", e);
}
if (sctpSocket == null && logger.isInfoEnabled()) {
logger.info(
"SctpConnection " + getID() + " closed" + " before SctpSocket accept()-ed.");
}
}
});
// Notify that from now on SCTP connection is considered functional
sctpSocket.setDataCallback(this);
// Setup iceSocket
DatagramSocket datagramSocket = connector.getDataSocket();
if (datagramSocket != null) {
this.iceSocket = new IceUdpSocketWrapper(datagramSocket);
} else {
this.iceSocket = new IceTcpSocketWrapper(connector.getDataTCPSocket());
}
DatagramPacket rcvPacket = new DatagramPacket(receiveBuffer, 0, receiveBuffer.length);
// Receive loop, breaks when SCTP socket is closed
try {
do {
iceSocket.receive(rcvPacket);
RawPacket raw =
new RawPacket(rcvPacket.getData(), rcvPacket.getOffset(), rcvPacket.getLength());
raw = transformer.reverseTransform(raw);
// Check for app data
if (raw == null) continue;
if (LOG_SCTP_PACKETS) {
LibJitsi.getPacketLoggingService()
.logPacket(
PacketLoggingService.ProtocolName.ICE4J,
new byte[] {0, 0, 0, (byte) (debugId + 1)},
remoteSctpPort,
new byte[] {0, 0, 0, (byte) debugId},
5000,
PacketLoggingService.TransportName.UDP,
false,
raw.getBuffer(),
raw.getOffset(),
raw.getLength());
}
// Pass network packet to SCTP stack
sctpSocket.onConnIn(raw.getBuffer(), raw.getOffset(), raw.getLength());
} while (true);
} finally {
// Eventually, close the socket although it should happen from
// expire().
synchronized (this) {
assocIsUp = false;
acceptedIncomingConnection = false;
if (sctpSocket != null) {
sctpSocket.close();
sctpSocket = null;
}
}
}
}
/**
* Notifies this instance that a <tt>DatagramPacket</tt> packet received on the data
* <tt>DatagramSocket</tt> of this <tt>Channel</tt> has been accepted for further processing
* within Jitsi Videobridge.
*
* @param pkt the accepted <tt>RawPacket</tt>.
*/
public void accepted(RawPacket pkt) {
// With native simulcast we don't have a notification when a stream
// has started/stopped. The simulcast manager implements a timeout
// for the high quality stream and it needs to be notified when
// the channel has accepted a datagram packet for the timeout to
// function correctly.
if (!hasLayers() || pkt == null) {
return;
}
// Find the layer that corresponds to this packet.
int acceptedSSRC = pkt.getSSRC();
SimulcastLayer[] layers = getSimulcastLayers();
SimulcastLayer acceptedLayer = null;
for (SimulcastLayer layer : layers) {
// We only care about the primary SSRC and not the RTX ssrc (or
// future FEC ssrc).
if ((int) layer.getPrimarySSRC() == acceptedSSRC) {
acceptedLayer = layer;
break;
}
}
// If this is not an RTP packet or if we can't find an accepted
// layer, log and return as it makes no sense to continue in this
// situation.
if (acceptedLayer == null) {
return;
}
// There are sequences of packets with increasing timestamps but without
// the marker bit set. Supposedly, they are probes to detect whether the
// bandwidth may increase. We think that they should cause neither the
// start nor the stop of any SimulcastLayer.
// XXX There's RawPacket#getPayloadLength() but the implementation
// includes pkt.paddingSize at the time of this writing and we do not
// know whether that's going to stay that way.
int pktPayloadLength = pkt.getLength() - pkt.getHeaderLength();
int pktPaddingSize = pkt.getPaddingSize();
if (pktPayloadLength <= pktPaddingSize) {
if (logger.isTraceEnabled()) {
logger.trace(
"pkt.payloadLength= "
+ pktPayloadLength
+ " <= pkt.paddingSize= "
+ pktPaddingSize
+ "("
+ pkt.getSequenceNumber()
+ ")");
}
return;
}
// NOTE(gp) we expect the base layer to be always on, so we never touch
// it or starve it.
// XXX Refer to the implementation of
// SimulcastLayer#touch(boolean, RawPacket) for an explanation of why we
// chose to use a return value.
boolean frameStarted = acceptedLayer.touch(pkt);
if (frameStarted) simulcastLayerFrameStarted(acceptedLayer, pkt, layers);
}
/**
* Listens for incoming datagrams, stores them for reading by the <tt>read</tt> method and
* notifies the local <tt>transferHandler</tt> that there's data to be read.
*/
public void run() {
DatagramPacket p = new DatagramPacket(buffer, 0, PACKET_RECEIVE_BUFFER_LENGTH);
while (!closed) {
try {
// http://code.google.com/p/android/issues/detail?id=24765
if (OSUtils.IS_ANDROID) p.setLength(PACKET_RECEIVE_BUFFER_LENGTH);
receivePacket(p);
} catch (IOException e) {
ioError = true;
break;
}
/*
* Do the DatagramPacketFilters accept the received DatagramPacket?
*/
DatagramPacketFilter[] datagramPacketFilters = getDatagramPacketFilters();
boolean accept;
if (!enabled) accept = false;
else if (datagramPacketFilters == null) accept = true;
else {
accept = true;
for (int i = 0; i < datagramPacketFilters.length; i++) {
try {
if (!datagramPacketFilters[i].accept(p)) {
accept = false;
break;
}
} catch (Throwable t) {
if (t instanceof ThreadDeath) throw (ThreadDeath) t;
}
}
}
if (accept) {
RawPacket pkts[] = createRawPacket(p);
for (int i = 0; i < pkts.length; i++) {
RawPacket pkt = pkts[i];
pkts[i] = null;
if (pkt != null) {
if (pkt.isInvalid()) {
/*
* Return pkt to the pool because it is invalid and,
* consequently, will not be made available to
* reading.
*/
poolRawPacket(pkt);
} else {
RawPacket oldPkt;
synchronized (pktSyncRoot) {
oldPkt = this.pkt;
this.pkt = pkt;
}
if (oldPkt != null) {
/*
* Return oldPkt to the pool because it was made
* available to reading and it was not read.
*/
poolRawPacket(oldPkt);
}
if (videoRecorder != null) videoRecorder.recordData(pkt);
if ((transferHandler != null) && !closed) {
try {
transferHandler.transferData(this);
} catch (Throwable t) {
/*
* XXX We cannot allow transferHandler to
* kill us.
*/
if (t instanceof ThreadDeath) {
throw (ThreadDeath) t;
} else {
logger.warn("An RTP packet may have not been" + " fully handled.", t);
}
}
}
}
}
}
rawPacketArrayPool.offer(pkts);
}
}
}