@Override
public RawPacket transform(RawPacket p) {
// Update octets and packets sent in SRs.
RTCPCompoundPacket compound;
try {
compound = (RTCPCompoundPacket) parser.parse(p.getBuffer(), p.getOffset(), p.getLength());
} catch (BadFormatException e) {
logger.warn("Failed to terminate an RTCP packet. Dropping it.");
return null;
}
if (srGateway.gateway(compound)) {
return generator.apply(compound);
} else {
// If the RTCP packet hasn't been modified, send the input
// without regenerating it (i.e. optimize).
return p;
}
}
/** {@inheritDoc} */
@Override
public RawPacket report() {
garbageCollector.cleanup();
// TODO Compound RTCP packets should not exceed the MTU of the network
// path.
//
// An individual RTP participant should send only one compound RTCP
// packet per report interval in order for the RTCP bandwidth per
// participant to be estimated correctly, except when the compound
// RTCP packet is split for partial encryption.
//
// If there are too many sources to fit all the necessary RR packets
// into one compound RTCP packet without exceeding the maximum
// transmission unit (MTU) of the network path, then only the subset
// that will fit into one MTU should be included in each interval. The
// subsets should be selected round-robin across multiple intervals so
// that all sources are reported.
//
// It is impossible to know in advance what the MTU of path will be.
// There are various algorithms for experimenting to find out, but many
// devices do not properly implement (or deliberately ignore) the
// necessary standards so it all comes down to trial and error. For that
// reason, we can just guess 1200 or 1500 bytes per message.
long time = System.currentTimeMillis();
Collection<RTCPPacket> packets = new ArrayList<RTCPPacket>();
// First, we build the RRs.
Collection<RTCPRRPacket> rrPackets = makeRTCPRRPackets(time);
if (rrPackets != null && rrPackets.size() != 0) {
packets.addAll(rrPackets);
}
// Next, we build the SRs.
Collection<RTCPSRPacket> srPackets = makeRTCPSRPackets(time);
if (srPackets != null && srPackets.size() != 0) {
packets.addAll(srPackets);
}
// Bail out if we have nothing to report.
if (packets.size() == 0) {
return null;
}
// Next, we build the REMB.
RTCPREMBPacket rembPacket = makeRTCPREMBPacket();
if (rembPacket != null) {
packets.add(rembPacket);
}
// Finally, we add an SDES packet.
RTCPSDESPacket sdesPacket = makeSDESPacket();
if (sdesPacket != null) {
packets.add(sdesPacket);
}
// Prepare the <tt>RTCPCompoundPacket</tt> to return.
RTCPPacket rtcpPackets[] = packets.toArray(new RTCPPacket[packets.size()]);
RTCPCompoundPacket cp = new RTCPCompoundPacket(rtcpPackets);
// Build the <tt>RTCPCompoundPacket</tt> and return the
// <tt>RawPacket</tt> to inject to the <tt>MediaStream</tt>.
return generator.apply(cp);
}
