/**
* 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;
}
public int write(byte[] buffer, int offset, int length, boolean transform) {
RawPacket pkt = rawPacketArray[0];
if (pkt == null) pkt = new RawPacket();
rawPacketArray[0] = pkt;
byte[] pktBuf = pkt.getBuffer();
if (pktBuf == null || pktBuf.length < length) {
pktBuf = new byte[length];
pkt.setBuffer(pktBuf);
}
System.arraycopy(buffer, offset, pktBuf, 0, length);
pkt.setOffset(0);
pkt.setLength(length);
if (transform) {
PacketTransformer packetTransformer =
isControlStream ? rtcpPacketTransformer : rtpPacketTransformer;
if (packetTransformer != null)
rawPacketArray = packetTransformer.reverseTransform(rawPacketArray);
}
SourceTransferHandler transferHandler;
PushSourceStream pushSourceStream;
try {
if (isControlStream) {
transferHandler = controlTransferHandler;
pushSourceStream = getControlInputStream();
} else {
transferHandler = dataTransferHandler;
pushSourceStream = getDataInputStream();
}
} catch (IOException ioe) {
throw new UndeclaredThrowableException(ioe);
}
for (int i = 0; i < rawPacketArray.length; i++) {
RawPacket packet = rawPacketArray[i];
// keep the first element for reuse
if (i != 0) rawPacketArray[i] = null;
if (packet != null) {
if (isControlStream) pendingControlPacket = packet;
else pendingDataPacket = packet;
if (transferHandler != null) {
transferHandler.transferData(pushSourceStream);
}
}
}
return length;
}
/**
* Encapsulates {@code pkt} in the RTX format, using {@code rtxSsrc} as its SSRC, and transmits it
* to {@link #channel} by injecting it in the {@code MediaStream}.
*
* @param pkt the packet to transmit.
* @param rtxSsrc the SSRC for the RTX stream.
* @return {@code true} if the packet was successfully retransmitted, {@code false} otherwise.
*/
private boolean encapsulateInRtxAndTransmit(RawPacket pkt, long rtxSsrc) {
byte[] buf = pkt.getBuffer();
int len = pkt.getLength();
int off = pkt.getOffset();
byte[] newBuf = buf;
if (buf.length < len + 2) {
// FIXME The byte array newly allocated and assigned to newBuf must
// be made known to pkt eventually.
newBuf = new byte[len + 2];
}
int osn = pkt.getSequenceNumber();
int headerLength = pkt.getHeaderLength();
int payloadLength = len - headerLength;
System.arraycopy(buf, off, newBuf, 0, headerLength);
// FIXME If newBuf is actually buf, then we will override the first two
// bytes of the payload bellow.
newBuf[headerLength] = (byte) ((osn >> 8) & 0xff);
newBuf[headerLength + 1] = (byte) (osn & 0xff);
System.arraycopy(buf, off + headerLength, newBuf, headerLength + 2, payloadLength);
// FIXME We tried to extend the payload of pkt by two bytes above but
// we never told pkt that its length has increased by these two bytes.
MediaStream mediaStream = channel.getStream();
if (mediaStream != null) {
pkt.setSSRC((int) rtxSsrc);
// Only call getNextRtxSequenceNumber() when we're sure we're going
// to transmit a packet, because it consumes a sequence number.
pkt.setSequenceNumber(getNextRtxSequenceNumber(rtxSsrc));
try {
mediaStream.injectPacket(pkt, /* data */ true, /* after */ null);
} catch (TransmissionFailedException tfe) {
logger.warn("Failed to transmit an RTX packet.");
return false;
}
}
return true;
}
/**
* Encapsulates {@code pkt} in the RTX format, using {@code rtxSsrc} as its SSRC, and transmits it
* to {@link #channel} by injecting it in the {@code MediaStream}.
*
* @param pkt the packet to transmit.
* @param rtxSsrc the SSRC for the RTX stream.
* @param after the {@code TransformEngine} in the chain of {@code TransformEngine}s of the
* associated {@code MediaStream} after which the injection of {@code pkt} is to begin
* @return {@code true} if the packet was successfully retransmitted, {@code false} otherwise.
*/
private boolean encapsulateInRtxAndTransmit(RawPacket pkt, long rtxSsrc, TransformEngine after) {
byte[] buf = pkt.getBuffer();
int len = pkt.getLength();
int off = pkt.getOffset();
byte[] newBuf = new byte[len + 2];
RawPacket rtxPkt = new RawPacket(newBuf, 0, len + 2);
int osn = pkt.getSequenceNumber();
int headerLength = pkt.getHeaderLength();
int payloadLength = pkt.getPayloadLength();
// Copy the header.
System.arraycopy(buf, off, newBuf, 0, headerLength);
// Set the OSN field.
newBuf[headerLength] = (byte) ((osn >> 8) & 0xff);
newBuf[headerLength + 1] = (byte) (osn & 0xff);
// Copy the payload.
System.arraycopy(buf, off + headerLength, newBuf, headerLength + 2, payloadLength);
MediaStream mediaStream = channel.getStream();
if (mediaStream != null) {
rtxPkt.setSSRC((int) rtxSsrc);
rtxPkt.setPayloadType(rtxPayloadType);
// Only call getNextRtxSequenceNumber() when we're sure we're going
// to transmit a packet, because it consumes a sequence number.
rtxPkt.setSequenceNumber(getNextRtxSequenceNumber(rtxSsrc));
try {
mediaStream.injectPacket(rtxPkt, /* data */ true, after);
} catch (TransmissionFailedException tfe) {
logger.warn("Failed to transmit an RTX packet.");
return false;
}
}
return true;
}
/**
* Adds a <tt>DatagramPacketFilter</tt> which allows dropping <tt>DatagramPacket</tt>s before they
* are converted into <tt>RawPacket</tt>s.
*
* @param datagramPacketFilter the <tt>DatagramPacketFilter</tt> which allows dropping
* <tt>DatagramPacket</tt>s before they are converted into <tt>RawPacket</tt>s
*/
public synchronized void addDatagramPacketFilter(DatagramPacketFilter datagramPacketFilter) {
if (datagramPacketFilter == null) throw new NullPointerException("datagramPacketFilter");
if (datagramPacketFilters == null) {
datagramPacketFilters = new DatagramPacketFilter[] {datagramPacketFilter};
} else {
final int length = datagramPacketFilters.length;
for (int i = 0; i < length; i++)
if (datagramPacketFilter.equals(datagramPacketFilters[i])) return;
DatagramPacketFilter[] newDatagramPacketFilters = new DatagramPacketFilter[length + 1];
System.arraycopy(datagramPacketFilters, 0, newDatagramPacketFilters, 0, length);
newDatagramPacketFilters[length] = datagramPacketFilter;
datagramPacketFilters = newDatagramPacketFilters;
}
}
@Override
public int read(byte[] buffer, int offset, int length) throws IOException {
RawPacket pendingPacket;
if (isControlStream) {
pendingPacket = pendingControlPacket;
} else {
pendingPacket = pendingDataPacket;
}
int bytesToRead = 0;
byte[] pendingPacketBuffer = pendingPacket.getBuffer();
if (pendingPacketBuffer != null) {
int pendingPacketLength = pendingPacket.getLength();
bytesToRead = length > pendingPacketLength ? pendingPacketLength : length;
System.arraycopy(
pendingPacketBuffer, pendingPacket.getOffset(), buffer, offset, bytesToRead);
}
return bytesToRead;
}
/**
* Removes the RTX encapsulation from a packet.
*
* @param pkt the packet to remove the RTX encapsulation from.
* @return the original media packet represented by {@code pkt}, or null if we couldn't
* reconstruct the original packet.
*/
private RawPacket deRtx(RawPacket pkt) {
boolean success = false;
if (pkt.getPayloadLength() - pkt.getPaddingSize() < 2) {
// We need at least 2 bytes to read the OSN field.
if (logger.isDebugEnabled()) {
logger.debug("Dropping an incoming RTX packet with padding only: " + pkt);
}
return null;
}
long mediaSsrc = getPrimarySsrc(pkt);
if (mediaSsrc != -1) {
if (rtxAssociatedPayloadType != -1) {
int osn = pkt.getOriginalSequenceNumber();
// Remove the RTX header by moving the RTP header two bytes
// right.
byte[] buf = pkt.getBuffer();
int off = pkt.getOffset();
System.arraycopy(buf, off, buf, off + 2, pkt.getHeaderLength());
pkt.setOffset(off + 2);
pkt.setLength(pkt.getLength() - 2);
pkt.setSSRC((int) mediaSsrc);
pkt.setSequenceNumber(osn);
pkt.setPayloadType(rtxAssociatedPayloadType);
success = true;
} else {
logger.warn(
"RTX packet received, but no APT is defined. Packet "
+ "SSRC "
+ pkt.getSSRCAsLong()
+ ", associated media"
+ " SSRC "
+ mediaSsrc);
}
}
// If we failed to handle the RTX packet, drop it.
return success ? pkt : null;
}
/**
* Creates a {@code RawPacket} which represents the original packet encapsulated in {@code pkt}
* using the RTX format.
*
* @param pkt the packet from which to extract a media packet.
* @return the extracted media packet.
*/
private RawPacket createMediaPacket(RawPacket pkt) {
RawPacket mediaPacket = null;
long rtxSsrc = pkt.getSSRC() & 0xffffffffL;
// We need to know the SSRC paired with rtxSsrc *as seen by the
// receiver (i.e. this.channel)*. However, we only store SSRCs
// that endpoints *send* with.
// We therefore assume that SSRC re-writing has not introduced any
// new SSRCs and therefor the FID mappings known to the senders
// also apply to receivers.
RtpChannel sourceChannel = channel.getContent().findChannelByFidSsrc(rtxSsrc);
if (sourceChannel != null) {
long mediaSsrc = sourceChannel.getFidPairedSsrc(rtxSsrc);
if (mediaSsrc != -1) {
byte apt = sourceChannel.getRtxAssociatedPayloadType();
if (apt != -1) {
mediaPacket = new RawPacket(pkt.getBuffer().clone(), pkt.getOffset(), pkt.getLength());
// Remove the RTX header by moving the RTP header two bytes
// right.
byte[] buf = mediaPacket.getBuffer();
int off = mediaPacket.getOffset();
System.arraycopy(buf, off, buf, off + 2, mediaPacket.getHeaderLength());
mediaPacket.setOffset(off + 2);
mediaPacket.setLength(pkt.getLength() - 2);
mediaPacket.setSSRC((int) mediaSsrc);
mediaPacket.setSequenceNumber(pkt.getOriginalSequenceNumber());
mediaPacket.setPayloadType(apt);
}
}
}
return mediaPacket;
}
/**
* Makes <tt>RTCPRRPacket</tt>s using information in FMJ.
*
* @param time
* @return A <tt>Collection</tt> of <tt>RTCPRRPacket</tt>s to inject to the <tt>MediaStream</tt>.
*/
private Collection<RTCPRRPacket> makeRTCPRRPackets(long time) {
RTCPReportBlock[] reportBlocks = makeRTCPReportBlocks(time);
if (reportBlocks == null || reportBlocks.length == 0) {
return null;
}
Collection<RTCPRRPacket> rrPackets = new ArrayList<RTCPRRPacket>();
// We use the stream's local source ID (SSRC) as the SSRC of packet
// sender.
long streamSSRC = getLocalSSRC();
// Since a maximum of 31 reception report blocks will fit in an SR
// or RR packet, additional RR packets SHOULD be stacked after the
// initial SR or RR packet as needed to contain the reception
// reports for all sources heard during the interval since the last
// report.
if (reportBlocks.length > MAX_RTCP_REPORT_BLOCKS) {
for (int offset = 0; offset < reportBlocks.length; offset += MAX_RTCP_REPORT_BLOCKS) {
RTCPReportBlock[] blocks =
(reportBlocks.length - offset < MAX_RTCP_REPORT_BLOCKS)
? new RTCPReportBlock[reportBlocks.length - offset]
: MAX_RTCP_REPORT_BLOCKS_ARRAY;
System.arraycopy(reportBlocks, offset, blocks, 0, blocks.length);
RTCPRRPacket rr = new RTCPRRPacket((int) streamSSRC, blocks);
rrPackets.add(rr);
}
} else {
RTCPRRPacket rr = new RTCPRRPacket((int) streamSSRC, reportBlocks);
rrPackets.add(rr);
}
return rrPackets;
}
/** {@inheritDoc} */
@Override
protected int doProcess(Buffer inBuffer, Buffer outBuffer) {
byte[] inData = (byte[]) inBuffer.getData();
int inOffset = inBuffer.getOffset();
if (!VP8PayloadDescriptor.isValid(inData, inOffset)) {
logger.warn("Invalid RTP/VP8 packet discarded.");
outBuffer.setDiscard(true);
return BUFFER_PROCESSED_FAILED; // XXX: FAILED or OK?
}
long inSeq = inBuffer.getSequenceNumber();
long inRtpTimestamp = inBuffer.getRtpTimeStamp();
int inPictureId = VP8PayloadDescriptor.getPictureId(inData, inOffset);
boolean inMarker = (inBuffer.getFlags() & Buffer.FLAG_RTP_MARKER) != 0;
boolean inIsStartOfFrame = VP8PayloadDescriptor.isStartOfFrame(inData, inOffset);
int inLength = inBuffer.getLength();
int inPdSize = VP8PayloadDescriptor.getSize(inData, inOffset);
int inPayloadLength = inLength - inPdSize;
if (empty && lastSentSeq != -1 && seqNumComparator.compare(inSeq, lastSentSeq) != 1) {
if (logger.isInfoEnabled()) logger.info("Discarding old packet (while empty) " + inSeq);
outBuffer.setDiscard(true);
return BUFFER_PROCESSED_OK;
}
if (!empty) {
// if the incoming packet has a different PictureID or timestamp
// than those of the current frame, then it belongs to a different
// frame.
if ((inPictureId != -1 && pictureId != -1 && inPictureId != pictureId)
| (timestamp != -1 && inRtpTimestamp != -1 && inRtpTimestamp != timestamp)) {
if (seqNumComparator.compare(inSeq, firstSeq) != 1) // inSeq <= firstSeq
{
// the packet belongs to a previous frame. discard it
if (logger.isInfoEnabled()) logger.info("Discarding old packet " + inSeq);
outBuffer.setDiscard(true);
return BUFFER_PROCESSED_OK;
} else // inSeq > firstSeq (and also presumably isSeq > lastSeq)
{
// the packet belongs to a subsequent frame (to the one
// currently being held). Drop the current frame.
if (logger.isInfoEnabled())
logger.info(
"Discarding saved packets on arrival of"
+ " a packet for a subsequent frame: "
+ inSeq);
// TODO: this would be the place to complain about the
// not-well-received PictureID by sending a RTCP SLI or NACK.
reinit();
}
}
}
// a whole frame in a single packet. avoid the extra copy to
// this.data and output it immediately.
if (empty && inMarker && inIsStartOfFrame) {
byte[] outData = validateByteArraySize(outBuffer, inPayloadLength, false);
System.arraycopy(inData, inOffset + inPdSize, outData, 0, inPayloadLength);
outBuffer.setOffset(0);
outBuffer.setLength(inPayloadLength);
outBuffer.setRtpTimeStamp(inBuffer.getRtpTimeStamp());
if (TRACE) logger.trace("Out PictureID=" + inPictureId);
lastSentSeq = inSeq;
return BUFFER_PROCESSED_OK;
}
// add to this.data
Container container = free.poll();
if (container == null) container = new Container();
if (container.buf == null || container.buf.length < inPayloadLength)
container.buf = new byte[inPayloadLength];
if (data.get(inSeq) != null) {
if (logger.isInfoEnabled())
logger.info("(Probable) duplicate packet detected, discarding " + inSeq);
outBuffer.setDiscard(true);
return BUFFER_PROCESSED_OK;
}
System.arraycopy(inData, inOffset + inPdSize, container.buf, 0, inPayloadLength);
container.len = inPayloadLength;
data.put(inSeq, container);
// update fields
frameLength += inPayloadLength;
if (firstSeq == -1 || (seqNumComparator.compare(firstSeq, inSeq) == 1)) firstSeq = inSeq;
if (lastSeq == -1 || (seqNumComparator.compare(inSeq, lastSeq) == 1)) lastSeq = inSeq;
if (empty) {
// the first received packet for the current frame was just added
empty = false;
timestamp = inRtpTimestamp;
pictureId = inPictureId;
}
if (inMarker) haveEnd = true;
if (inIsStartOfFrame) haveStart = true;
// check if we have a full frame
if (frameComplete()) {
byte[] outData = validateByteArraySize(outBuffer, frameLength, false);
int ptr = 0;
Container b;
for (Map.Entry<Long, Container> entry : data.entrySet()) {
b = entry.getValue();
System.arraycopy(b.buf, 0, outData, ptr, b.len);
ptr += b.len;
}
outBuffer.setOffset(0);
outBuffer.setLength(frameLength);
outBuffer.setRtpTimeStamp(inBuffer.getRtpTimeStamp());
if (TRACE) logger.trace("Out PictureID=" + inPictureId);
lastSentSeq = lastSeq;
// prepare for the next frame
reinit();
return BUFFER_PROCESSED_OK;
} else {
// frame not complete yet
outBuffer.setDiscard(true);
return OUTPUT_BUFFER_NOT_FILLED;
}
}
/**
* Initializes a new <tt>SRTPTransformer</tt> instance with a specific (negotiated)
* <tt>SRTPProtectionProfile</tt> and the keying material specified by a specific
* <tt>TlsContext</tt>.
*
* @param srtpProtectionProfile the (negotiated) <tt>SRTPProtectionProfile</tt> to initialize the
* new instance with
* @param tlsContext the <tt>TlsContext</tt> which represents the keying material
* @return a new <tt>SRTPTransformer</tt> instance initialized with <tt>srtpProtectionProfile</tt>
* and <tt>tlsContext</tt>
*/
private SinglePacketTransformer initializeSRTPTransformer(
int srtpProtectionProfile, TlsContext tlsContext) {
boolean rtcp;
switch (componentID) {
case Component.RTCP:
rtcp = true;
break;
case Component.RTP:
rtcp = false;
break;
default:
throw new IllegalStateException("componentID");
}
int cipher_key_length;
int cipher_salt_length;
int cipher;
int auth_function;
int auth_key_length;
int RTCP_auth_tag_length, RTP_auth_tag_length;
switch (srtpProtectionProfile) {
case SRTPProtectionProfile.SRTP_AES128_CM_HMAC_SHA1_32:
cipher_key_length = 128 / 8;
cipher_salt_length = 112 / 8;
cipher = SRTPPolicy.AESCM_ENCRYPTION;
auth_function = SRTPPolicy.HMACSHA1_AUTHENTICATION;
auth_key_length = 160 / 8;
RTCP_auth_tag_length = 80 / 8;
RTP_auth_tag_length = 32 / 8;
break;
case SRTPProtectionProfile.SRTP_AES128_CM_HMAC_SHA1_80:
cipher_key_length = 128 / 8;
cipher_salt_length = 112 / 8;
cipher = SRTPPolicy.AESCM_ENCRYPTION;
auth_function = SRTPPolicy.HMACSHA1_AUTHENTICATION;
auth_key_length = 160 / 8;
RTCP_auth_tag_length = RTP_auth_tag_length = 80 / 8;
break;
case SRTPProtectionProfile.SRTP_NULL_HMAC_SHA1_32:
cipher_key_length = 0;
cipher_salt_length = 0;
cipher = SRTPPolicy.NULL_ENCRYPTION;
auth_function = SRTPPolicy.HMACSHA1_AUTHENTICATION;
auth_key_length = 160 / 8;
RTCP_auth_tag_length = 80 / 8;
RTP_auth_tag_length = 32 / 8;
break;
case SRTPProtectionProfile.SRTP_NULL_HMAC_SHA1_80:
cipher_key_length = 0;
cipher_salt_length = 0;
cipher = SRTPPolicy.NULL_ENCRYPTION;
auth_function = SRTPPolicy.HMACSHA1_AUTHENTICATION;
auth_key_length = 160 / 8;
RTCP_auth_tag_length = RTP_auth_tag_length = 80 / 8;
break;
default:
throw new IllegalArgumentException("srtpProtectionProfile");
}
byte[] keyingMaterial =
tlsContext.exportKeyingMaterial(
ExporterLabel.dtls_srtp, null, 2 * (cipher_key_length + cipher_salt_length));
byte[] client_write_SRTP_master_key = new byte[cipher_key_length];
byte[] server_write_SRTP_master_key = new byte[cipher_key_length];
byte[] client_write_SRTP_master_salt = new byte[cipher_salt_length];
byte[] server_write_SRTP_master_salt = new byte[cipher_salt_length];
byte[][] keyingMaterialValues = {
client_write_SRTP_master_key,
server_write_SRTP_master_key,
client_write_SRTP_master_salt,
server_write_SRTP_master_salt
};
for (int i = 0, keyingMaterialOffset = 0; i < keyingMaterialValues.length; i++) {
byte[] keyingMaterialValue = keyingMaterialValues[i];
System.arraycopy(
keyingMaterial, keyingMaterialOffset, keyingMaterialValue, 0, keyingMaterialValue.length);
keyingMaterialOffset += keyingMaterialValue.length;
}
SRTPPolicy srtcpPolicy =
new SRTPPolicy(
cipher,
cipher_key_length,
auth_function,
auth_key_length,
RTCP_auth_tag_length,
cipher_salt_length);
SRTPPolicy srtpPolicy =
new SRTPPolicy(
cipher,
cipher_key_length,
auth_function,
auth_key_length,
RTP_auth_tag_length,
cipher_salt_length);
SRTPContextFactory clientSRTPContextFactory =
new SRTPContextFactory(
/* sender */ tlsContext instanceof TlsClientContext,
client_write_SRTP_master_key,
client_write_SRTP_master_salt,
srtpPolicy,
srtcpPolicy);
SRTPContextFactory serverSRTPContextFactory =
new SRTPContextFactory(
/* sender */ tlsContext instanceof TlsServerContext,
server_write_SRTP_master_key,
server_write_SRTP_master_salt,
srtpPolicy,
srtcpPolicy);
SRTPContextFactory forwardSRTPContextFactory;
SRTPContextFactory reverseSRTPContextFactory;
if (tlsContext instanceof TlsClientContext) {
forwardSRTPContextFactory = clientSRTPContextFactory;
reverseSRTPContextFactory = serverSRTPContextFactory;
} else if (tlsContext instanceof TlsServerContext) {
forwardSRTPContextFactory = serverSRTPContextFactory;
reverseSRTPContextFactory = clientSRTPContextFactory;
} else {
throw new IllegalArgumentException("tlsContext");
}
SinglePacketTransformer srtpTransformer;
if (rtcp) {
srtpTransformer = new SRTCPTransformer(forwardSRTPContextFactory, reverseSRTPContextFactory);
} else {
srtpTransformer = new SRTPTransformer(forwardSRTPContextFactory, reverseSRTPContextFactory);
}
return srtpTransformer;
}