/**
* {@inheritDoc}
*
* @param format unused, since this implementation records multiple streams using potentially
* different formats.
* @param dirname the path to the directory into which this <tt>Recorder</tt> will store the
* recorded media files.
*/
@Override
public void start(String format, String dirname) throws IOException, MediaException {
if (logger.isInfoEnabled()) logger.info("Starting, format=" + format + " " + hashCode());
path = dirname;
MediaService mediaService = LibJitsi.getMediaService();
/*
* Note that we use only one RTPConnector for both the RTPTranslator
* and the RTPManager instances. The this.translator will write to its
* output streams, and this.rtpManager will read from its input streams.
*/
rtpConnector = new RTPConnectorImpl(redPayloadType, ulpfecPayloadType);
rtpManager = RTPManager.newInstance();
/*
* Add the formats that we know about.
*/
rtpManager.addFormat(vp8RtpFormat, vp8PayloadType);
rtpManager.addFormat(opusFormat, opusPayloadType);
rtpManager.addReceiveStreamListener(this);
/*
* Note: When this.rtpManager sends RTCP sender/receiver reports, they
* will end up being written to its own input stream. This is not
* expected to cause problems, but might be something to keep an eye on.
*/
rtpManager.initialize(rtpConnector);
/*
* Register a fake call participant.
* TODO: can we use a more generic MediaStream here?
*/
streamRTPManager =
new StreamRTPManager(
mediaService.createMediaStream(
new MediaDeviceImpl(new CaptureDeviceInfo(), MediaType.VIDEO)),
translator);
streamRTPManager.initialize(rtpConnector);
rtcpFeedbackSender = translator.getRtcpFeedbackMessageSender();
translator.addFormat(streamRTPManager, opusFormat, opusPayloadType);
// ((RTPTranslatorImpl)videoRTPTranslator).addFormat(streamRTPManager, redFormat,
// redPayloadType);
// ((RTPTranslatorImpl)videoRTPTranslator).addFormat(streamRTPManager, ulpfecFormat,
// ulpfecPayloadType);
// ((RTPTranslatorImpl)videoRTPTranslator).addFormat(streamRTPManager,
// mediaFormatImpl.getFormat(), vp8PayloadType);
started = true;
}
protected void doInitialize() throws Exception {
DSCaptureDevice devices[] = DSManager.getInstance().getCaptureDevices();
boolean captureDeviceInfoIsAdded = false;
for (int i = 0, count = (devices == null) ? 0 : devices.length; i < count; i++) {
long pixelFormat = devices[i].getFormat().getPixelFormat();
int ffmpegPixFmt = (int) DataSource.getFFmpegPixFmt(pixelFormat);
Format format = null;
if (ffmpegPixFmt != FFmpeg.PIX_FMT_NONE) {
format = new AVFrameFormat(ffmpegPixFmt, (int) pixelFormat);
} else {
logger.warn(
"No support for this webcam: "
+ devices[i].getName()
+ "(format "
+ pixelFormat
+ " not supported)");
continue;
}
if (logger.isInfoEnabled()) {
for (DSFormat f : devices[i].getSupportedFormats()) {
if (f.getWidth() != 0 && f.getHeight() != 0)
logger.info(
"Webcam available resolution for "
+ devices[i].getName()
+ ":"
+ f.getWidth()
+ "x"
+ f.getHeight());
}
}
CaptureDeviceInfo device =
new CaptureDeviceInfo(
devices[i].getName(),
new MediaLocator(LOCATOR_PROTOCOL + ':' + devices[i].getName()),
new Format[] {format});
if (logger.isInfoEnabled()) logger.info("Found[" + i + "]: " + device.getName());
CaptureDeviceManager.addDevice(device);
captureDeviceInfoIsAdded = true;
}
if (captureDeviceInfoIsAdded && !MediaServiceImpl.isJmfRegistryDisableLoad())
CaptureDeviceManager.commit();
DSManager.dispose();
}
/**
* Gets the <tt>MediaFormat</tt>s among the specified <tt>mediaFormats</tt> which have the
* specified <tt>encoding</tt> and, optionally, <tt>clockRate</tt>.
*
* @param mediaFormats the <tt>MediaFormat</tt>s from which to filter out only the ones which have
* the specified <tt>encoding</tt> and, optionally, <tt>clockRate</tt>
* @param encoding the well-known encoding (name) of the <tt>MediaFormat</tt>s to be retrieved
* @param clockRate the clock rate of the <tt>MediaFormat</tt>s to be retrieved; {@link
* #CLOCK_RATE_NOT_SPECIFIED} if any clock rate is acceptable
* @return a <tt>List</tt> of the <tt>MediaFormat</tt>s among <tt>mediaFormats</tt> which have the
* specified <tt>encoding</tt> and, optionally, <tt>clockRate</tt>
*/
private List<MediaFormat> getMatchingMediaFormats(
MediaFormat[] mediaFormats, String encoding, double clockRate) {
/*
* XXX Use String#equalsIgnoreCase(String) because some clients transmit
* some of the codecs starting with capital letters.
*/
/*
* As per RFC 3551.4.5.2, because of a mistake in RFC 1890 and for
* backward compatibility, G.722 should always be announced as 8000 even
* though it is wideband. So, if someone is looking for G722/16000,
* then: Forgive them, for they know not what they do!
*/
if ("G722".equalsIgnoreCase(encoding) && (16000 == clockRate)) {
clockRate = 8000;
if (logger.isInfoEnabled()) logger.info("Suppressing erroneous 16000 announcement for G.722");
}
List<MediaFormat> supportedMediaFormats = new ArrayList<MediaFormat>();
for (MediaFormat mediaFormat : mediaFormats) {
if (mediaFormat.getEncoding().equalsIgnoreCase(encoding)
&& ((CLOCK_RATE_NOT_SPECIFIED == clockRate)
|| (mediaFormat.getClockRate() == clockRate))) {
supportedMediaFormats.add(mediaFormat);
}
}
return supportedMediaFormats;
}
/**
* Capture a part of the desktop screen using <tt>java.awt.Robot</tt>.
*
* @param x x position to start capture
* @param y y position to start capture
* @param width capture width
* @param height capture height
* @return <tt>BufferedImage</tt> of a part of the desktop screen or null if Robot problem
*/
public BufferedImage captureScreen(int x, int y, int width, int height) {
BufferedImage img = null;
Rectangle rect = null;
if (robot == null) {
/* Robot has not been created so abort */
return null;
}
if (logger.isInfoEnabled()) logger.info("Begin capture: " + System.nanoTime());
rect = new Rectangle(x, y, width, height);
img = robot.createScreenCapture(rect);
if (logger.isInfoEnabled()) logger.info("End capture: " + System.nanoTime());
return img;
}
/**
* Stop desktop capture stream.
*
* @see AbstractPullBufferStream#stop()
*/
@Override
public void stop() throws IOException {
try {
if (logger.isInfoEnabled()) logger.info("Stop stream");
} finally {
super.stop();
byteBufferPool.drain();
}
}
/**
* Starts the <tt>msofficecomm</tt> bundle in a specific {@link BundleContext}.
*
* @param bundleContext the <tt>BundleContext</tt> in which the <tt>msofficecomm</tt> bundle is to
* be started
* @throws Exception if anything goes wrong while starting the <tt>msofficecomm</tt> bundle in the
* specified <tt>BundleContext</tt>
*/
public void start(BundleContext bundleContext) throws Exception {
// The msofficecomm bundle is available on Windows only.
if (!OSUtils.IS_WINDOWS) return;
if (logger.isInfoEnabled()) logger.info("MsOfficeComm plugin ... [STARTED]");
Messenger.start(bundleContext);
boolean stopMessenger = true;
try {
int hresult = OutOfProcessServer.start();
if (logger.isInfoEnabled())
logger.info("MsOfficeComm started OutOfProcessServer HRESULT:" + hresult);
if (hresult < 0) throw new RuntimeException("HRESULT " + hresult);
else stopMessenger = false;
} finally {
if (stopMessenger) Messenger.stop(bundleContext);
}
}
/**
* Restarts the recording for a specific SSRC.
*
* @param ssrc the SSRC for which to restart recording. RTP packet of the new recording).
*/
private void resetRecording(long ssrc, long timestamp) {
ReceiveStreamDesc receiveStream = findReceiveStream(ssrc);
// we only restart audio recordings
if (receiveStream != null && receiveStream.format instanceof AudioFormat) {
String newFilename = getNextFilename(path + "/" + ssrc, AUDIO_FILENAME_SUFFIX);
// flush the buffer contained in the MP3 encoder
String s = "trying to flush ssrc=" + ssrc;
Processor p = receiveStream.processor;
if (p != null) {
s += " p!=null";
for (TrackControl tc : p.getTrackControls()) {
Object o = tc.getControl(FlushableControl.class.getName());
if (o != null) ((FlushableControl) o).flush();
}
}
if (logger.isInfoEnabled()) {
logger.info("Restarting recording for SSRC=" + ssrc + ". New filename: " + newFilename);
}
receiveStream.dataSink.close();
receiveStream.dataSink = null;
// flush the FMJ jitter buffer
// DataSource ds = receiveStream.receiveStream.getDataSource();
// if (ds instanceof net.sf.fmj.media.protocol.rtp.DataSource)
// ((net.sf.fmj.media.protocol.rtp.DataSource)ds).flush();
receiveStream.filename = newFilename;
try {
receiveStream.dataSink =
Manager.createDataSink(
receiveStream.dataSource, new MediaLocator("file:" + newFilename));
} catch (NoDataSinkException ndse) {
logger.warn("Could not reset recording for SSRC=" + ssrc + ": " + ndse);
removeReceiveStream(receiveStream, false);
}
try {
receiveStream.dataSink.open();
receiveStream.dataSink.start();
} catch (IOException ioe) {
logger.warn("Could not reset recording for SSRC=" + ssrc + ": " + ioe);
removeReceiveStream(receiveStream, false);
}
audioRecordingStarted(ssrc, timestamp);
}
}
/**
* Stops the <tt>msofficecomm</tt> bundle in a specific {@link BundleContext}.
*
* @param bundleContext the <tt>BundleContext</tt> in which the <tt>msofficecomm</tt> bundle is to
* be stopped
* @throws Exception if anything goes wrong while stopping the <tt>msofficecomm</tt> bundle in the
* specified <tt>BundleContext</tt>
*/
public void stop(BundleContext bundleContext) throws Exception {
// The msofficecomm bundle is available on Windows only.
if (!OSUtils.IS_WINDOWS) return;
try {
int hresult = OutOfProcessServer.stop();
if (hresult < 0) throw new RuntimeException("HRESULT " + hresult);
} finally {
Messenger.stop(bundleContext);
}
if (logger.isInfoEnabled()) logger.info("MsOfficeComm plugin ... [UNREGISTERED]");
}
/**
* Expires this <tt>Conference</tt>, its <tt>Content</tt>s and their respective <tt>Channel</tt>s.
* Releases the resources acquired by this instance throughout its life time and prepares it to be
* garbage collected.
*/
public void expire() {
synchronized (this) {
if (expired) return;
else expired = true;
}
EventAdmin eventAdmin = videobridge.getEventAdmin();
if (eventAdmin != null) eventAdmin.sendEvent(EventFactory.conferenceExpired(this));
setRecording(false);
if (recorderEventHandler != null) {
recorderEventHandler.close();
recorderEventHandler = null;
}
Videobridge videobridge = getVideobridge();
try {
videobridge.expireConference(this);
} finally {
// Expire the Contents of this Conference.
for (Content content : getContents()) {
try {
content.expire();
} catch (Throwable t) {
logger.warn(
"Failed to expire content " + content.getName() + " of conference " + getID() + "!",
t);
if (t instanceof InterruptedException) Thread.currentThread().interrupt();
else if (t instanceof ThreadDeath) throw (ThreadDeath) t;
}
}
// Close the transportManagers of this Conference. Normally, there
// will be no TransportManager left to close at this point because
// all Channels have expired and the last Channel to be removed from
// a TransportManager closes the TransportManager. However, a
// Channel may have expired before it has learned of its
// TransportManager and then the TransportManager will not close.
closeTransportManagers();
if (logger.isInfoEnabled()) {
logger.info(
"Expired conference " + getID() + ". " + videobridge.getConferenceCountString());
}
}
}
@Override
public void stop() {
if (started) {
if (logger.isInfoEnabled()) logger.info("Stopping " + hashCode());
// remove the recorder from the translator (e.g. stop new packets from
// being written to rtpConnector
if (streamRTPManager != null) streamRTPManager.dispose();
HashSet<ReceiveStreamDesc> streamsToRemove = new HashSet<ReceiveStreamDesc>();
synchronized (receiveStreams) {
streamsToRemove.addAll(receiveStreams);
}
for (ReceiveStreamDesc r : streamsToRemove) removeReceiveStream(r, false);
rtpConnector.rtcpPacketTransformer.close();
rtpConnector.rtpPacketTransformer.close();
rtpManager.dispose();
started = false;
}
}
/**
* Gets a <tt>Content</tt> of this <tt>Conference</tt> which has a specific name. If a
* <tt>Content</tt> of this <tt>Conference</tt> with the specified <tt>name</tt> does not exist at
* the time the method is invoked, the method initializes a new <tt>Content</tt> instance with the
* specified <tt>name</tt> and adds it to the list of <tt>Content</tt>s of this
* <tt>Conference</tt>.
*
* @param name the name of the <tt>Content</tt> which is to be returned
* @return a <tt>Content</tt> of this <tt>Conference</tt> which has the specified <tt>name</tt>
*/
public Content getOrCreateContent(String name) {
Content content;
synchronized (contents) {
for (Content aContent : contents) {
if (aContent.getName().equals(name)) {
aContent.touch(); // It seems the content is still active.
return aContent;
}
}
content = new Content(this, name);
if (isRecording()) {
content.setRecording(true, getRecordingPath());
}
contents.add(content);
}
if (logger.isInfoEnabled()) {
/*
* The method Videobridge.getChannelCount() should better be
* executed outside synchronized blocks in order to reduce the risks
* of causing deadlocks.
*/
Videobridge videobridge = getVideobridge();
logger.info(
"Created content "
+ name
+ " of conference "
+ getID()
+ ". "
+ videobridge.getConferenceCountString());
}
return content;
}
/**
* 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.
}
/**
* Implements {@link ReceiveStreamListener#update(ReceiveStreamEvent)}.
*
* <p>{@link #rtpManager} will use this to notify us of <tt>ReceiveStreamEvent</tt>s.
*/
@Override
public void update(ReceiveStreamEvent event) {
if (event == null) return;
ReceiveStream receiveStream = event.getReceiveStream();
if (event instanceof NewReceiveStreamEvent) {
if (receiveStream == null) {
logger.warn("NewReceiveStreamEvent: null");
return;
}
final long ssrc = getReceiveStreamSSRC(receiveStream);
ReceiveStreamDesc receiveStreamDesc = findReceiveStream(ssrc);
if (receiveStreamDesc != null) {
String s = "NewReceiveStreamEvent for an existing SSRC. ";
if (receiveStream != receiveStreamDesc.receiveStream)
s += "(but different ReceiveStream object)";
logger.warn(s);
return;
} else receiveStreamDesc = new ReceiveStreamDesc(receiveStream);
if (logger.isInfoEnabled()) logger.info("New ReceiveStream, ssrc=" + ssrc);
// Find the format of the ReceiveStream
DataSource dataSource = receiveStream.getDataSource();
if (dataSource instanceof PushBufferDataSource) {
Format format = null;
PushBufferDataSource pbds = (PushBufferDataSource) dataSource;
for (PushBufferStream pbs : pbds.getStreams()) {
if ((format = pbs.getFormat()) != null) break;
}
if (format == null) {
logger.error("Failed to handle new ReceiveStream: " + "Failed to determine format");
return;
}
receiveStreamDesc.format = format;
} else {
logger.error("Failed to handle new ReceiveStream: " + "Unsupported DataSource");
return;
}
int rtpClockRate = -1;
if (receiveStreamDesc.format instanceof AudioFormat)
rtpClockRate = (int) ((AudioFormat) receiveStreamDesc.format).getSampleRate();
else if (receiveStreamDesc.format instanceof VideoFormat) rtpClockRate = 90000;
getSynchronizer().setRtpClockRate(ssrc, rtpClockRate);
// create a Processor and configure it
Processor processor = null;
try {
processor = Manager.createProcessor(receiveStream.getDataSource());
} catch (NoProcessorException npe) {
logger.error("Failed to create Processor: ", npe);
return;
} catch (IOException ioe) {
logger.error("Failed to create Processor: ", ioe);
return;
}
if (logger.isInfoEnabled()) logger.info("Created processor for SSRC=" + ssrc);
processor.addControllerListener(this);
receiveStreamDesc.processor = processor;
final int streamCount;
synchronized (receiveStreams) {
receiveStreams.add(receiveStreamDesc);
streamCount = receiveStreams.size();
}
/*
* XXX TODO IRBABOON
* This is a terrible hack which works around a failure to realize()
* some of the Processor-s for audio streams, when multiple streams
* start nearly simultaneously. The cause of the problem is currently
* unknown (and synchronizing all FMJ calls in RecorderRtpImpl
* does not help).
* XXX TODO NOOBABRI
*/
if (receiveStreamDesc.format instanceof AudioFormat) {
final Processor p = processor;
new Thread() {
@Override
public void run() {
// delay configuring the processors for the different
// audio streams to decrease the probability that they
// run together.
try {
int ms = 450 * (streamCount - 1);
logger.warn(
"Sleeping for "
+ ms
+ "ms before"
+ " configuring processor for SSRC="
+ ssrc
+ " "
+ System.currentTimeMillis());
Thread.sleep(ms);
} catch (Exception e) {
}
p.configure();
}
}.run();
} else {
processor.configure();
}
} else if (event instanceof TimeoutEvent) {
if (receiveStream == null) {
// TODO: we might want to get the list of ReceiveStream-s from
// rtpManager and compare it to our list, to see if we should
// remove a stream.
logger.warn("TimeoutEvent: null.");
return;
}
// FMJ silently creates new ReceiveStream instances, so we have to
// recognize them by the SSRC.
ReceiveStreamDesc receiveStreamDesc = findReceiveStream(getReceiveStreamSSRC(receiveStream));
if (receiveStreamDesc != null) {
if (logger.isInfoEnabled()) {
logger.info("ReceiveStream timeout, ssrc=" + receiveStreamDesc.ssrc);
}
removeReceiveStream(receiveStreamDesc, true);
}
} else if (event != null && logger.isInfoEnabled()) {
logger.info("Unhandled ReceiveStreamEvent (" + event.getClass().getName() + "): " + event);
}
}
/** {@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;
}
}
/** {@inheritDoc} */
@Override
protected void doOpen() throws ResourceUnavailableException {
if (logger.isInfoEnabled()) logger.info("Opened VP8 depacketizer");
}
/**
* Implements {@link ControllerListener#controllerUpdate(ControllerEvent)}. Handles events from
* the <tt>Processor</tt>s that this instance uses to transcode media.
*
* @param ev the event to handle.
*/
public void controllerUpdate(ControllerEvent ev) {
if (ev == null || ev.getSourceController() == null) {
return;
}
Processor processor = (Processor) ev.getSourceController();
ReceiveStreamDesc desc = findReceiveStream(processor);
if (desc == null) {
logger.warn("Event from an orphaned processor, ignoring: " + ev);
return;
}
if (ev instanceof ConfigureCompleteEvent) {
if (logger.isInfoEnabled()) {
logger.info(
"Configured processor for ReceiveStream ssrc="
+ desc.ssrc
+ " ("
+ desc.format
+ ")"
+ " "
+ System.currentTimeMillis());
}
boolean audio = desc.format instanceof AudioFormat;
if (audio) {
ContentDescriptor cd = processor.setContentDescriptor(AUDIO_CONTENT_DESCRIPTOR);
if (!AUDIO_CONTENT_DESCRIPTOR.equals(cd)) {
logger.error(
"Failed to set the Processor content "
+ "descriptor to "
+ AUDIO_CONTENT_DESCRIPTOR
+ ". Actual result: "
+ cd);
removeReceiveStream(desc, false);
return;
}
}
for (TrackControl track : processor.getTrackControls()) {
Format trackFormat = track.getFormat();
if (audio) {
final long ssrc = desc.ssrc;
SilenceEffect silenceEffect;
if (Constants.OPUS_RTP.equals(desc.format.getEncoding())) {
silenceEffect = new SilenceEffect(48000);
} else {
// We haven't tested that the RTP timestamps survive
// the journey through the chain when codecs other than
// opus are in use, so for the moment we rely on FMJ's
// timestamps for non-opus formats.
silenceEffect = new SilenceEffect();
}
silenceEffect.setListener(
new SilenceEffect.Listener() {
boolean first = true;
@Override
public void onSilenceNotInserted(long timestamp) {
if (first) {
first = false;
// send event only
audioRecordingStarted(ssrc, timestamp);
} else {
// change file and send event
resetRecording(ssrc, timestamp);
}
}
});
desc.silenceEffect = silenceEffect;
AudioLevelEffect audioLevelEffect = new AudioLevelEffect();
audioLevelEffect.setAudioLevelListener(
new SimpleAudioLevelListener() {
@Override
public void audioLevelChanged(int level) {
activeSpeakerDetector.levelChanged(ssrc, level);
}
});
try {
// We add an effect, which will insert "silence" in
// place of lost packets.
track.setCodecChain(new Codec[] {silenceEffect, audioLevelEffect});
} catch (UnsupportedPlugInException upie) {
logger.warn("Failed to insert silence effect: " + upie);
// But do go on, a recording without extra silence is
// better than nothing ;)
}
} else {
// transcode vp8/rtp to vp8 (i.e. depacketize vp8)
if (trackFormat.matches(vp8RtpFormat)) track.setFormat(vp8Format);
else {
logger.error("Unsupported track format: " + trackFormat + " for ssrc=" + desc.ssrc);
// we currently only support vp8
removeReceiveStream(desc, false);
return;
}
}
}
processor.realize();
} else if (ev instanceof RealizeCompleteEvent) {
desc.dataSource = processor.getDataOutput();
long ssrc = desc.ssrc;
boolean audio = desc.format instanceof AudioFormat;
String suffix = audio ? AUDIO_FILENAME_SUFFIX : VIDEO_FILENAME_SUFFIX;
// XXX '\' on windows?
String filename = getNextFilename(path + "/" + ssrc, suffix);
desc.filename = filename;
DataSink dataSink;
if (audio) {
try {
dataSink = Manager.createDataSink(desc.dataSource, new MediaLocator("file:" + filename));
} catch (NoDataSinkException ndse) {
logger.error("Could not create DataSink: " + ndse);
removeReceiveStream(desc, false);
return;
}
} else {
dataSink = new WebmDataSink(filename, desc.dataSource);
}
if (logger.isInfoEnabled())
logger.info(
"Created DataSink ("
+ dataSink
+ ") for SSRC="
+ ssrc
+ ". Output filename: "
+ filename);
try {
dataSink.open();
} catch (IOException e) {
logger.error("Failed to open DataSink (" + dataSink + ") for" + " SSRC=" + ssrc + ": " + e);
removeReceiveStream(desc, false);
return;
}
if (!audio) {
final WebmDataSink webmDataSink = (WebmDataSink) dataSink;
webmDataSink.setSsrc(ssrc);
webmDataSink.setEventHandler(eventHandler);
webmDataSink.setKeyFrameControl(
new KeyFrameControlAdapter() {
@Override
public boolean requestKeyFrame(boolean urgent) {
return requestFIR(webmDataSink);
}
});
}
try {
dataSink.start();
} catch (IOException e) {
logger.error(
"Failed to start DataSink (" + dataSink + ") for" + " SSRC=" + ssrc + ". " + e);
removeReceiveStream(desc, false);
return;
}
if (logger.isInfoEnabled()) logger.info("Started DataSink for SSRC=" + ssrc);
desc.dataSink = dataSink;
processor.start();
} else if (logger.isDebugEnabled()) {
logger.debug(
"Unhandled ControllerEvent from the Processor for ssrc=" + desc.ssrc + ": " + ev);
}
}
private void logInfo(String msg) {
if (logger.isInfoEnabled()) {
msg = getSimulcastEngine().getVideoChannel().getEndpoint().getID() + ": " + msg;
logger.info(msg);
}
}