/**
* Makes <tt>RTCPSRPacket</tt>s for all the RTP streams that we're sending.
*
* @return a <tt>List</tt> of <tt>RTCPSRPacket</tt> for all the RTP streams that we're sending.
*/
private Collection<RTCPSRPacket> makeRTCPSRPackets(long time) {
Collection<RTCPSRPacket> srPackets = new ArrayList<RTCPSRPacket>();
for (RTPStatsEntry rtpStatsEntry : rtpStatsMap.values()) {
int ssrc = rtpStatsEntry.getSsrc();
RemoteClock estimate = remoteClockEstimator.estimate(ssrc, time);
if (estimate == null) {
// We're not going to go far without an estimate..
continue;
}
RTCPSRPacket srPacket = new RTCPSRPacket(ssrc, MIN_RTCP_REPORTS_BLOCKS_ARRAY);
// Set the NTP timestamp for this SR.
long estimatedRemoteTime = estimate.getRemoteTime();
long secs = estimatedRemoteTime / 1000L;
double fraction = (estimatedRemoteTime - secs * 1000L) / 1000D;
srPacket.ntptimestamplsw = (int) (fraction * 4294967296D);
srPacket.ntptimestampmsw = secs;
// Set the RTP timestamp.
srPacket.rtptimestamp = estimate.getRtpTimestamp();
// Fill-in packet and octet send count.
srPacket.packetcount = rtpStatsEntry.getPacketsSent();
srPacket.octetcount = rtpStatsEntry.getBytesSent();
srPackets.add(srPacket);
}
return srPackets;
}
/**
* 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;
}
/**
* 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;
}
/**
* 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);
}