/**
* {@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;
}
/**
* 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);
}
}
@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;
}
}
/**
* 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);
}
}
/**
* 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);
}
}
/**
* Starts the execution of the neomedia bundle in the specified context.
*
* @param bundleContext the context in which the neomedia bundle is to start executing
* @throws Exception if an error occurs while starting the execution of the neomedia bundle in the
* specified context
*/
public void start(BundleContext bundleContext) throws Exception {
if (logger.isDebugEnabled()) logger.debug("Started.");
NeomediaActivator.bundleContext = bundleContext;
// MediaService
mediaServiceImpl = (MediaServiceImpl) LibJitsi.getMediaService();
bundleContext.registerService(MediaService.class.getName(), mediaServiceImpl, null);
if (logger.isDebugEnabled()) logger.debug("Media Service ... [REGISTERED]");
// mediaConfiguration = new MediaConfigurationImpl();
// bundleContext.registerService(
// MediaConfigurationService.class.getStatus(),
// getMediaConfiguration(),
// null);
if (logger.isDebugEnabled()) logger.debug("Media Configuration ... [REGISTERED]");
ConfigurationService cfg = NeomediaActivator.getConfigurationService();
Dictionary<String, String> mediaProps = new Hashtable<String, String>();
mediaProps.put(ConfigurationForm.FORM_TYPE, ConfigurationForm.GENERAL_TYPE);
// If the audio configuration form is disabled don't register it.
// if ((cfg == null) || !cfg.getBoolean(AUDIO_CONFIG_DISABLED_PROP, false))
// {
// audioConfigurationForm
// = new LazyConfigurationForm(
// AudioConfigurationPanel.class.getStatus(),
// getClass().getClassLoader(),
// "plugin.mediaconfig.AUDIO_ICON",
// "impl.neomedia.configform.AUDIO",
// 3);
//
// bundleContext.registerService(
// ConfigurationForm.class.getStatus(),
// audioConfigurationForm,
// mediaProps);
//
// if (deviceConfigurationPropertyChangeListener == null)
// {
// // Initializes and registers the changed device configuration
// // event ot the notification service.
// getNotificationService();
//
// deviceConfigurationPropertyChangeListener
// = new AudioDeviceConfigurationListener();
// mediaServiceImpl
// .getDeviceConfiguration()
// .addPropertyChangeListener(
// deviceConfigurationPropertyChangeListener);
// }
// }
// If the video configuration form is disabled don't register it.
// if ((cfg == null) || !cfg.getBoolean(VIDEO_CONFIG_DISABLED_PROP, false))
// {
// bundleContext.registerService(
// ConfigurationForm.class.getStatus(),
// new LazyConfigurationForm(
// VideoConfigurationPanel.class.getStatus(),
// getClass().getClassLoader(),
// "plugin.mediaconfig.VIDEO_ICON",
// "impl.neomedia.configform.VIDEO",
// 4),
// mediaProps);
// }
// H.264
// If the H.264 configuration form is disabled don't register it.
// if ((cfg == null) || !cfg.getBoolean(H264_CONFIG_DISABLED_PROP, false))
// {
// Dictionary<String, String> h264Props
// = new Hashtable<String, String>();
//
// h264Props.put(
// ConfigurationForm.FORM_TYPE,
// ConfigurationForm.ADVANCED_TYPE);
// bundleContext.registerService(
// ConfigurationForm.class.getStatus(),
// new LazyConfigurationForm(
// ConfigurationPanel.class.getStatus(),
// getClass().getClassLoader(),
// "plugin.mediaconfig.VIDEO_ICON",
// "impl.neomedia.configform.H264",
// -1,
// true),
// h264Props);
// }
// ZRTP
// If the ZRTP configuration form is disabled don't register it.
// if ((cfg == null) || !cfg.getBoolean(ZRTP_CONFIG_DISABLED_PROP, false))
// {
// Dictionary<String, String> securityProps
// = new Hashtable<String, String>();
//
// securityProps.put( ConfigurationForm.FORM_TYPE,
// ConfigurationForm.SECURITY_TYPE);
// bundleContext.registerService(
// ConfigurationForm.class.getStatus(),
// new LazyConfigurationForm(
// SecurityConfigForm.class.getStatus(),
// getClass().getClassLoader(),
// "impl.media.security.zrtp.CONF_ICON",
// "impl.media.security.zrtp.TITLE",
// 0),
// securityProps);
// }
// we use the nist-sdp stack to make parse sdp and we need to set the
// following property to make sure that it would accept java generated
// IPv6 addresses that contain address scope zones.
System.setProperty("gov.nist.core.STRIP_ADDR_SCOPES", "true");
// AudioNotifierService
AudioNotifierService audioNotifierService = LibJitsi.getAudioNotifierService();
audioNotifierService.setMute(
(cfg == null)
|| !cfg.getBoolean("net.java.sip.communicator" + ".impl.sound.isSoundEnabled", true));
bundleContext.registerService(AudioNotifierService.class.getName(), audioNotifierService, null);
if (logger.isInfoEnabled()) logger.info("Audio Notifier Service ...[REGISTERED]");
// Call Recording
// If the call recording configuration form is disabled don't continue.
// if ((cfg == null)
// || !cfg.getBoolean(CALL_RECORDING_CONFIG_DISABLED_PROP, false))
// {
// Dictionary<String, String> callRecordingProps
// = new Hashtable<String, String>();
//
// callRecordingProps.put(
// ConfigurationForm.FORM_TYPE,
// ConfigurationForm.ADVANCED_TYPE);
// bundleContext.registerService(
// ConfigurationForm.class.getStatus(),
// new LazyConfigurationForm(
// CallRecordingConfigForm.class.getStatus(),
// getClass().getClassLoader(),
// null,
// "plugin.callrecordingconfig.CALL_RECORDING_CONFIG",
// 1100,
// true),
// callRecordingProps);
// }
}