/**
* Makes an <tt>RTCPREMBPacket</tt> that provides receiver feedback to the endpoint from which we
* receive.
*
* @return an <tt>RTCPREMBPacket</tt> that provides receiver feedback to the endpoint from which
* we receive.
*/
private RTCPREMBPacket makeRTCPREMBPacket() {
// TODO we should only make REMBs if REMB support has been advertised.
// Destination
RemoteBitrateEstimator remoteBitrateEstimator =
((VideoMediaStream) getStream()).getRemoteBitrateEstimator();
Collection<Integer> ssrcs = remoteBitrateEstimator.getSsrcs();
// TODO(gp) intersect with SSRCs from signaled simulcast layers
// NOTE(gp) The Google Congestion Control algorithm (sender side)
// doesn't seem to care about the SSRCs in the dest field.
long[] dest = new long[ssrcs.size()];
int i = 0;
for (Integer ssrc : ssrcs) dest[i++] = ssrc & 0xFFFFFFFFL;
// Exp & mantissa
long bitrate = remoteBitrateEstimator.getLatestEstimate();
if (bitrate == -1) return null;
if (logger.isDebugEnabled()) logger.debug("Estimated bitrate: " + bitrate);
// Create and return the packet.
// We use the stream's local source ID (SSRC) as the SSRC of packet
// sender.
long streamSSRC = getLocalSSRC();
return new RTCPREMBPacket(streamSSRC, /* mediaSSRC */ 0L, bitrate, dest);
}
/**
* Makes <tt>RTCPSDES</tt> packets for all the RTP streams that we're sending.
*
* @return a <tt>List</tt> of <tt>RTCPSDES</tt> packets for all the RTP streams that we're
* sending.
*/
private RTCPSDESPacket makeSDESPacket() {
Collection<RTCPSDES> sdesChunks = new ArrayList<RTCPSDES>();
// Create an SDES for our own SSRC.
RTCPSDES ownSDES = new RTCPSDES();
SSRCInfo ourinfo = getStream().getStreamRTPManager().getSSRCCache().ourssrc;
ownSDES.ssrc = (int) getLocalSSRC();
Collection<RTCPSDESItem> ownItems = new ArrayList<RTCPSDESItem>();
ownItems.add(new RTCPSDESItem(RTCPSDESItem.CNAME, ourinfo.sourceInfo.getCNAME()));
// Throttle the source description bandwidth. See RFC3550#6.3.9
// Allocation of Source Description Bandwidth.
if (sdesCounter % 3 == 0) {
if (ourinfo.name != null && ourinfo.name.getDescription() != null)
ownItems.add(new RTCPSDESItem(RTCPSDESItem.NAME, ourinfo.name.getDescription()));
if (ourinfo.email != null && ourinfo.email.getDescription() != null)
ownItems.add(new RTCPSDESItem(RTCPSDESItem.EMAIL, ourinfo.email.getDescription()));
if (ourinfo.phone != null && ourinfo.phone.getDescription() != null)
ownItems.add(new RTCPSDESItem(RTCPSDESItem.PHONE, ourinfo.phone.getDescription()));
if (ourinfo.loc != null && ourinfo.loc.getDescription() != null)
ownItems.add(new RTCPSDESItem(RTCPSDESItem.LOC, ourinfo.loc.getDescription()));
if (ourinfo.tool != null && ourinfo.tool.getDescription() != null)
ownItems.add(new RTCPSDESItem(RTCPSDESItem.TOOL, ourinfo.tool.getDescription()));
if (ourinfo.note != null && ourinfo.note.getDescription() != null)
ownItems.add(new RTCPSDESItem(RTCPSDESItem.NOTE, ourinfo.note.getDescription()));
}
sdesCounter++;
ownSDES.items = ownItems.toArray(new RTCPSDESItem[ownItems.size()]);
sdesChunks.add(ownSDES);
for (Map.Entry<Integer, byte[]> entry : cnameRegistry.entrySet()) {
RTCPSDES sdes = new RTCPSDES();
sdes.ssrc = entry.getKey();
sdes.items = new RTCPSDESItem[] {new RTCPSDESItem(RTCPSDESItem.CNAME, entry.getValue())};
}
RTCPSDES[] sps = sdesChunks.toArray(new RTCPSDES[sdesChunks.size()]);
RTCPSDESPacket sp = new RTCPSDESPacket(sps);
return sp;
}
/**
* Removes receiver and sender feedback from RTCP packets.
*
* @param inPacket the <tt>RTCPCompoundPacket</tt> to filter.
* @return the filtered <tt>RawPacket</tt>.
*/
public RawPacket gateway(RTCPCompoundPacket inPacket) {
if (inPacket == null || inPacket.packets == null || inPacket.packets.length == 0) {
logger.info("Ignoring empty RTCP packet.");
return null;
}
ArrayList<RTCPPacket> outPackets = new ArrayList<RTCPPacket>(inPacket.packets.length);
for (RTCPPacket p : inPacket.packets) {
switch (p.type) {
case RTCPPacket.RR:
case RTCPPacket.SR:
case RTCPPacket.SDES:
// We generate our own RR/SR/SDES packets. We only want
// to forward NACKs/PLIs/etc.
break;
case RTCPFBPacket.PSFB:
RTCPFBPacket psfb = (RTCPFBPacket) p;
switch (psfb.fmt) {
case RTCPREMBPacket.FMT:
// We generate its own REMB packets.
break;
default:
// We let through everything else, like NACK
// packets.
outPackets.add(psfb);
break;
}
break;
default:
// We let through everything else, like BYE and APP
// packets.
outPackets.add(p);
break;
}
}
if (outPackets.size() == 0) {
return null;
}
// We have feedback messages to send. Pack them in a compound
// RR and send them. TODO Use RFC5506 Reduced-Size RTCP, if the
// receiver supports it.
Collection<RTCPRRPacket> rrPackets = makeRTCPRRPackets(System.currentTimeMillis());
if (rrPackets != null && rrPackets.size() != 0) {
outPackets.addAll(0, rrPackets);
} else {
logger.warn("We might be sending invalid RTCPs.");
}
RTCPPacket[] pkts = outPackets.toArray(new RTCPPacket[outPackets.size()]);
RTCPCompoundPacket outPacket = new RTCPCompoundPacket(pkts);
return generator.apply(outPacket);
}
/**
* Iterate through all the <tt>ReceiveStream</tt>s that this <tt>MediaStream</tt> has and make
* <tt>RTCPReportBlock</tt>s for all of them.
*
* @param time
* @return
*/
private RTCPReportBlock[] makeRTCPReportBlocks(long time) {
MediaStream stream = getStream();
// State validation.
if (stream == null) {
logger.warn("stream is null.");
return MIN_RTCP_REPORTS_BLOCKS_ARRAY;
}
StreamRTPManager streamRTPManager = stream.getStreamRTPManager();
if (streamRTPManager == null) {
logger.warn("streamRTPManager is null.");
return MIN_RTCP_REPORTS_BLOCKS_ARRAY;
}
Collection<ReceiveStream> receiveStreams = streamRTPManager.getReceiveStreams();
if (receiveStreams == null || receiveStreams.size() == 0) {
logger.info("There are no receive streams to build report " + "blocks for.");
return MIN_RTCP_REPORTS_BLOCKS_ARRAY;
}
SSRCCache cache = streamRTPManager.getSSRCCache();
if (cache == null) {
logger.info("cache is null.");
return MIN_RTCP_REPORTS_BLOCKS_ARRAY;
}
// Create the return object.
Collection<RTCPReportBlock> rtcpReportBlocks = new ArrayList<RTCPReportBlock>();
// Populate the return object.
for (ReceiveStream receiveStream : receiveStreams) {
// Dig into the guts of FMJ and get the stats for the current
// receiveStream.
SSRCInfo info = cache.cache.get((int) receiveStream.getSSRC());
if (!info.ours && info.sender) {
RTCPReportBlock rtcpReportBlock = info.makeReceiverReport(time);
rtcpReportBlocks.add(rtcpReportBlock);
}
}
return rtcpReportBlocks.toArray(new RTCPReportBlock[rtcpReportBlocks.size()]);
}
/** {@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);
}