/**
* Determines whether {@code effect} has been paused/stopped by the remote peer. The determination
* is based on counting frames and is triggered by the receipt of (a piece of) a new (video) frame
* by {@code cause}.
*
* @param cause the {@code SimulcastLayer} which has received (a piece of) a new (video) frame and
* has thus triggered a check on {@code effect}
* @param pkt the {@code RawPacket} which was received by {@code cause} and possibly influenced
* the decision to trigger a check on {@code effect}
* @param effect the {@code SimulcastLayer} which is to be checked whether it looks like it has
* been paused/stopped by the remote peer
* @param endIndexInSimulcastLayerFrameHistory
*/
private void maybeTimeout(
SimulcastLayer cause,
RawPacket pkt,
SimulcastLayer effect,
int endIndexInSimulcastLayerFrameHistory) {
Iterator<SimulcastLayer> it = simulcastLayerFrameHistory.iterator();
boolean timeout = true;
for (int ix = 0; it.hasNext() && ix < endIndexInSimulcastLayerFrameHistory; ++ix) {
if (it.next() == effect) {
timeout = false;
break;
}
}
if (timeout) {
effect.maybeTimeout(pkt);
if (!effect.isStreaming()) {
// Since effect has been determined to have been paused/stopped
// by the remote peer, its possible presence in
// simulcastLayerFrameHistory is irrelevant now. In other words,
// remove effect from simulcastLayerFrameHistory.
while (it.hasNext()) {
if (it.next() == effect) it.remove();
}
}
}
}
/**
* Notifies this {@code SimulcastReceiver} that a specific {@code SimulcastReceiver} has detected
* the start of a new video frame in the RTP stream that it represents. Determines whether any of
* {@link #simulcastLayers} other than {@code source} have been paused/stopped by the remote peer.
* The determination is based on counting (video) frames.
*
* @param source the {@code SimulcastLayer} which is the source of the event i.e. which has
* detected the start of a new video frame in the RTP stream that it represents
* @param pkt the {@code RawPacket} which was received by {@code source} and possibly influenced
* the decision that a new view frame was started in the RTP stream represented by {@code
* source}
* @param layers the set of {@code SimulcastLayer}s managed by this {@code SimulcastReceiver}.
* Explicitly provided to the method in order to avoid invocations of {@link
* #getSimulcastLayers()} because the latter makes a copy at the time of this writing.
*/
private void simulcastLayerFrameStarted(
SimulcastLayer source, RawPacket pkt, SimulcastLayer[] layers) {
// Allow the value of the constant TIMEOUT_ON_FRAME_COUNT to disable (at
// compile time) the frame-based approach to the detection of layer
// drops.
if (TIMEOUT_ON_FRAME_COUNT <= 1) return;
// Timeouts in layers caused by source may occur only based on the span
// (of time or received frames) during which source has received
// TIMEOUT_ON_FRAME_COUNT number of frames. The current method
// invocation signals the receipt of 1 frame by source.
int indexOfLastSourceOccurrenceInHistory = -1;
int sourceFrameCount = 0;
int ix = 0;
for (Iterator<SimulcastLayer> it = simulcastLayerFrameHistory.iterator(); it.hasNext(); ++ix) {
if (it.next() == source) {
if (indexOfLastSourceOccurrenceInHistory != -1) {
// Prune simulcastLayerFrameHistory so that it does not
// become unnecessarily long.
it.remove();
} else if (++sourceFrameCount >= TIMEOUT_ON_FRAME_COUNT - 1) {
// The span of TIMEOUT_ON_FRAME_COUNT number of frames
// received by source only is to be examined for the
// purposes of timeouts. The current method invocations
// signals the receipt of 1 frame by source so
// TIMEOUT_ON_FRAME_COUNT - 1 occurrences of source in
// simulcastLayerFrameHistory is enough.
indexOfLastSourceOccurrenceInHistory = ix;
}
}
}
if (indexOfLastSourceOccurrenceInHistory != -1) {
// Presumably, if a SimulcastLayer is active, all SimulcastLayers
// before it (according to SimulcastLayer's order) are active as
// well. Consequently, timeouts may occur in SimulcastLayers which
// are after source.
boolean maybeTimeout = false;
for (SimulcastLayer layer : layers) {
if (maybeTimeout) {
// There's no point in timing layer out if it's timed out
// already.
if (layer.isStreaming()) {
maybeTimeout(source, pkt, layer, indexOfLastSourceOccurrenceInHistory);
}
} else if (layer == source) {
maybeTimeout = true;
}
}
}
// As previously stated, the current method invocation signals the
// receipt of 1 frame by source.
simulcastLayerFrameHistory.add(0, source);
// TODO Prune simulcastLayerFrameHistory by forgetting so that it does
// not become too long.
}
/**
* Sets the simulcast layers for this receiver and fires an event about it.
*
* @param simulcastLayers the simulcast layers for this receiver.
*/
public void setSimulcastLayers(SimulcastLayer[] simulcastLayers) {
this.simulcastLayers = simulcastLayers;
if (logger.isInfoEnabled()) {
if (simulcastLayers == null) {
logInfo("Simulcast disabled.");
} else {
for (SimulcastLayer l : simulcastLayers) {
logInfo(l.getOrder() + ": " + l.getPrimarySSRC());
}
}
}
executorService.execute(
new Runnable() {
public void run() {
firePropertyChange(SIMULCAST_LAYERS_PNAME, null, null);
}
});
// TODO If simulcastLayers has changed, then simulcastLayerFrameHistory
// has very likely become irrelevant. In other words, clear
// simulcastLayerFrameHistory.
}
/**
* 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);
}
