public synchronized boolean waitForState(int state) {
switch (state) {
case Processor.Configured:
p.configure();
break;
case Controller.Realized:
p.realize();
break;
case Controller.Prefetched:
p.prefetch();
break;
case Controller.Started:
p.start();
break;
}
while (p.getState() < state && !error) {
try {
wait(1000);
} catch (Exception e) {
}
}
// p.removeControllerListener(this);
return !(error);
}
private synchronized boolean waitForState(Processor p, int state) {
p.addControllerListener(new StateListener());
failed = false;
// Call the required method on the processor
if (state == Processor.Configured) {
p.configure();
} else if (state == Processor.Realized) {
p.realize();
}
// Wait until we get an event that confirms the
// success of the method, or a failure event.
// See StateListener inner class
while (p.getState() < state && !failed) {
synchronized (getStateLock()) {
try {
getStateLock().wait();
} catch (InterruptedException ie) {
return false;
}
}
}
if (failed) return false;
else return true;
}
/**
* Callback for controller events. This method is called by the processor whenever state changes.
*
* @param event - describes the nature of the state change.
*/
public synchronized void controllerUpdate(ControllerEvent event) {
if (event instanceof ConfigureCompleteEvent) {
// ConfigurationCompleteEvents come after we
// call configure() and before we can call realize().
// At this point we can query the controls to figure
// out what tracks we have.
// Debug.trace("ConfigureCompleteEvent");
setHandlers();
// set content descriptor to null
// so that the processor can be used as a player
processor.setContentDescriptor(null);
// request transition to realized state
processor.realize();
} else if (event instanceof RealizeCompleteEvent) {
// RealizeCompleteEvents come after we call realize() and
// before we can call start() or do anything else interesting.
// Debug.trace("RealizeCompleteEvent");
controlThread.setState(REALIZED | REWOUND);
// at this point we should be able to access duration
// we convert it to the vrml convention (-1 for unknown)
double vrmlDuration;
Time duration = processor.getDuration();
if (duration == Duration.DURATION_UNKNOWN || duration == Duration.DURATION_UNBOUNDED) {
vrmlDuration = -1.0;
} else {
vrmlDuration = duration.getSeconds();
}
videoHandler.videoStreamDuration(vrmlDuration);
// finally we call prefetch will will send the first
// frame to the video handler.
processor.prefetch();
} else if (event instanceof StartEvent) {
controlThread.setState(STARTED); // set STARTED
controlThread.unsetState(REWOUND); // clear REWOUND
} else if (event instanceof StopEvent) {
// includes EndOfMediaEvent, StopByRequestEvent
controlThread.unsetState(STARTED); // clear STARTED
} else if (event instanceof MediaTimeSetEvent) {
controlThread.setState(TIMESET); // notify any waiting thread
}
}
private static synchronized boolean waitForState(Processor p, int state) {
p.addControllerListener(new StateListener());
stateFailed = false;
if (state == Processor.Configured) {
p.configure();
} else if (state == Processor.Realized) {
p.realize();
}
while (p.getState() < state && !stateFailed) {
synchronized (stateLock) {
try {
stateLock.wait();
} catch (InterruptedException ie) {
return false;
}
}
}
return (!stateFailed);
}
public static void main(String[] args) {
if (args.length != 2) {
System.out.println("Usage: rtpaudio <targetIP> <targetPort>");
System.exit(0);
}
try {
RegistryDefaults.setDefaultFlags(RegistryDefaults.FMJ);
// create a clean registry
RegistryDefaults.unRegisterAll(RegistryDefaults.ALL);
RegistryDefaults.registerAll(RegistryDefaults.FMJ);
// remove all capture devices
Vector deviceList = (Vector) CaptureDeviceManager.getDeviceList(null).clone();
for (int i = 0; i < deviceList.size(); i++) {
CaptureDeviceInfo cdi = (CaptureDeviceInfo) deviceList.elementAt(i);
CaptureDeviceManager.removeDevice(cdi);
}
// update capture device list
new net.sf.fmj.media.cdp.javasound.CaptureDevicePlugger().addCaptureDevices();
PlugInManager.commit();
deviceList = (Vector) CaptureDeviceManager.getDeviceList(null).clone();
if ((null == deviceList) || (deviceList.size() == 0)) {
System.out.println("### ERROR found no audio capture device");
System.exit(0);
}
// enumerate all codec
Vector codecList = PlugInManager.getPlugInList(null, null, PlugInManager.CODEC);
System.out.println("found " + codecList.size() + " codec");
for (int i = 0; i < codecList.size(); i++) {
String aCodecClass = (String) codecList.elementAt(i);
System.out.println("# " + (i + 1) + " " + aCodecClass);
}
// fetch first available audio capture device
deviceList = (Vector) CaptureDeviceManager.getDeviceList(null).clone();
CaptureDeviceInfo captureDeviceInfo = (CaptureDeviceInfo) deviceList.elementAt(0);
System.out.println("### using " + captureDeviceInfo.getName());
System.out.println("### locator " + captureDeviceInfo.getLocator());
javax.media.protocol.DataSource dataSource =
javax.media.Manager.createDataSource(
new javax.media.MediaLocator(captureDeviceInfo.getLocator().toString()));
// javax.media.protocol.DataSource dataSource =
// javax.media.Manager.createDataSource(new
// javax.media.MediaLocator("javasound://"));
System.out.println("### created datasource " + dataSource.getClass().getName());
javax.media.control.FormatControl[] formatControls =
((javax.media.protocol.CaptureDevice) dataSource).getFormatControls();
System.out.println("got format control " + formatControls[0].getClass().getName());
System.out.println("current format is " + formatControls[0].getFormat());
// set audio capture format
javax.media.Format[] formats = formatControls[0].getSupportedFormats();
for (int i = 0; i < formats.length; i++) {
javax.media.format.AudioFormat af = (javax.media.format.AudioFormat) formats[i];
if ((af.getChannels() == 1) && (af.getSampleSizeInBits() == 16)) {
if (af.getSampleRate() == Format.NOT_SPECIFIED) {
javax.media.format.AudioFormat newAudioFormat =
new javax.media.format.AudioFormat(
af.getEncoding(),
8000.0f,
javax.media.Format.NOT_SPECIFIED,
javax.media.Format.NOT_SPECIFIED);
// javax.media.format.AudioFormat newAudioFormat = new
// javax.media.format.AudioFormat(af.getEncoding(),
// 44100.0f, javax.media.Format.NOT_SPECIFIED,
// javax.media.Format.NOT_SPECIFIED);
formatControls[0].setFormat(newAudioFormat.intersects(af));
break;
}
}
}
System.out.println("current format is now " + formatControls[0].getFormat());
FrameProcessingControl fpc = null;
// adujst recording buffer ( to adjust latency )
dataSource.stop();
Object[] controls = dataSource.getControls();
for (int i = 0; i < controls.length; i++) {
String className = controls[i].getClass().getName();
if (-1 != className.indexOf("JavaSoundBufferControl")) {
javax.media.control.BufferControl bc = (javax.media.control.BufferControl) controls[i];
System.out.println(
"### current javasound buffer length is " + bc.getBufferLength() + " ms");
bc.setBufferLength(40);
System.out.println(
"### current javasound buffer length is " + bc.getBufferLength() + " ms");
} else if (-1 != className.indexOf("JitterBufferControl")) {
javax.media.control.BufferControl bc = (javax.media.control.BufferControl) controls[i];
System.out.println("### current jitter buffer length is " + bc.getBufferLength() + " ms");
bc.setBufferLength(80);
System.out.println("### current jitter buffer length is " + bc.getBufferLength() + " ms");
} else if (-1 != className.indexOf("FPC")) {
fpc = (FrameProcessingControl) controls[i];
System.out.println("### found bitrate control " + fpc.getClass());
}
}
dataSource.start();
// create processor
javax.media.Processor processor = javax.media.Manager.createProcessor(dataSource);
System.out.println("### created processor " + processor.getClass().getName());
processor.configure();
for (int idx = 0; idx < 100; idx++) {
if (processor.getState() == Processor.Configured) {
break;
}
Thread.sleep(100);
}
System.out.println("### processor state " + processor.getState());
processor.setContentDescriptor(
new javax.media.protocol.ContentDescriptor(ContentDescriptor.RAW_RTP));
javax.media.control.TrackControl[] tracks = processor.getTrackControls();
// /tracks[0].setFormat(new
// javax.media.format.AudioFormat(javax.media.format.AudioFormat.ULAW_RTP,
// 8000, 8, 1));
tracks[0].setFormat(
new javax.media.format.AudioFormat(javax.media.format.AudioFormat.GSM_RTP, 8000, 8, 1));
processor.realize();
for (int idx = 0; idx < 100; idx++) {
if (processor.getState() == Controller.Realized) {
break;
}
Thread.sleep(100);
}
System.out.println("### processor state " + processor.getState());
javax.media.protocol.DataSource dataOutput = processor.getDataOutput();
System.out.println("### processor data output " + dataOutput.getClass().getName());
// BitRateControl
BitRateControl bitrateControl = null;
Object[] controls2 = dataOutput.getControls();
for (int i = 0; i < controls2.length; i++) {
if (controls2[i] instanceof BitRateControl) {
bitrateControl = (BitRateControl) controls2[i];
System.out.println("### found bitrate control " + bitrateControl.getClass());
break;
}
}
// PacketSizeControl
Object[] controls3 = processor.getControls();
for (int i = 0; i < controls3.length; i++) {
if (controls3[i] instanceof PacketSizeControl) {
PacketSizeControl psc = (PacketSizeControl) controls3[i];
System.out.println("### current packetsize is " + psc.getPacketSize() + " bytes");
psc.setPacketSize(66);
System.out.println("### current packetsize is " + psc.getPacketSize() + " bytes");
break;
}
}
// enumerate all controls of the processor
Object[] pcontrols = processor.getControls();
for (int i = 0; i < pcontrols.length; i++) {
System.out.println("processor control " + i + " " + pcontrols[i]);
}
javax.media.rtp.RTPManager rtpManager = javax.media.rtp.RTPManager.newInstance();
javax.media.rtp.SessionAddress local =
new javax.media.rtp.SessionAddress(
InetAddress.getLocalHost(), Integer.valueOf(args[1]).intValue());
javax.media.rtp.SessionAddress target =
new javax.media.rtp.SessionAddress(
InetAddress.getByName(args[0]), Integer.valueOf(args[1]).intValue());
rtpManager.initialize(local);
rtpManager.addTarget(target);
javax.media.rtp.SendStream sendStream = rtpManager.createSendStream(dataOutput, 0);
sendStream.start();
processor.start();
Thread.sleep(1000);
System.out.println("\n>>>>>> TRANSMITTING ULAW/RTP AUDIO NOW");
while (2 > 1) {
Thread.sleep(1000);
if (null != bitrateControl) {
TransmissionStats stats = sendStream.getSourceTransmissionStats();
System.out.println(
"rtp audio send: bitrate="
+ bitrateControl.getBitRate()
+ " (pdu="
+ stats.getPDUTransmitted()
+ " bytes="
+ stats.getBytesTransmitted()
+ " overrun="
+ fpc.getFramesDropped()
+ ")");
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
System.exit(0);
}
/**
* 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);
}
}
