private static void openSound(IStreamCoder aAudioCoder) {
/* xuggler defaults to signed 16 bit samples */
AudioFormat audioFormat =
new AudioFormat(
aAudioCoder.getSampleRate(),
(int) IAudioSamples.findSampleBitDepth(aAudioCoder.getSampleFormat()),
aAudioCoder.getChannels(),
true,
false);
DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
try {
mLine = (SourceDataLine) AudioSystem.getLine(info);
/** if that succeeded, try opening the line. */
mLine.open(audioFormat);
/** And if that succeed, start the line. */
mLine.start();
} catch (LineUnavailableException e) {
throw new RuntimeException("could not open audio line");
}
}
public void decode() {
int success = videoStream.open();
if (success < 0) {
throw new RuntimeException(
"XUGGLER DECODER: could not open video decoder for container: "
+ input.getLocation().getDecodedURL());
}
IAudioSamples decodeSamples = null;
if (audioStream != null) {
success = audioStream.open();
if (success < 0) {
throw new RuntimeException(
"XUGGLER DECODER: could not open audio decoder for container: "
+ input.getLocation().getDecodedURL());
}
decodeSamples = IAudioSamples.make(1024, audioStream.getChannels());
}
IVideoPicture decodePicture =
IVideoPicture.make(
videoStream.getPixelType(), videoStream.getWidth(), videoStream.getHeight());
while (container.readNextPacket(packet) >= 0 && decodeMode != DecodeMode.STOP) {
/** Find out if this stream has a starting timestamp */
IStream stream = container.getStream(packet.getStreamIndex());
long tsOffset = 0;
if (stream.getStartTime() != Global.NO_PTS
&& stream.getStartTime() > 0
&& stream.getTimeBase() != null) {
IRational defTimeBase = IRational.make(1, (int) Global.DEFAULT_PTS_PER_SECOND);
tsOffset = defTimeBase.rescale(stream.getStartTime(), stream.getTimeBase());
}
/*
* Now we have a packet, let's see if it belongs to our video stream
*/
if (packet.getStreamIndex() == videoStreamIndex) {
int offset = 0;
while (offset < packet.getSize()) {
/*
* Now, we decode the video, checking for any errors.
*
*/
int bytesDecoded = videoStream.decodeVideo(decodePicture, packet, offset);
if (bytesDecoded < 0) {
throw new RuntimeException(
"XUGGLER: error decoding video in: " + input.getLocation().getDecodedURL());
}
if (decodePicture.getTimeStamp() != Global.NO_PTS) {
decodePicture.setTimeStamp(decodePicture.getTimeStamp() - tsOffset);
}
offset += bytesDecoded;
/*
* Some decoders will consume data in a packet, but will not be able to construct
* a full video picture yet. Therefore you should always check if you
* got a complete picture from the decoder
*/
if (decodePicture.isComplete()) {
decodedPicture(decodePicture);
}
}
} else if (audioStream != null
&& packet.getStreamIndex() == audioStreamIndex
&& decodeMode != DecodeMode.IGNORE_AUDIO) {
/*
* A packet can actually contain multiple sets of samples (or frames of samples
* in audio-decoding speak). So, we may need to call decode audio multiple
* times at different offsets in the packet's data. We capture that here.
*/
int offset = 0;
/*
* Keep going until we've processed all data
*/
while (offset < packet.getSize()) {
int bytesDecoded = audioStream.decodeAudio(decodeSamples, packet, offset);
if (bytesDecoded < 0) {
break;
// throw new RuntimeException("XUGGLER: got error decoding audio in: " +
// inputVideoFile);
}
if (decodeSamples.getTimeStamp() != Global.NO_PTS) {
decodeSamples.setTimeStamp(decodeSamples.getTimeStamp() - tsOffset);
}
offset += bytesDecoded;
/*
* Some decoder will consume data in a packet, but will not be able to construct
* a full set of samples yet. Therefore you should always check if you
* got a complete set of samples from the decoder
*/
if (decodeSamples.isComplete()) {
decodedAudioSamples(decodeSamples);
}
}
} else {
/*
* This packet isn't part of our video stream, so we just
* silently drop it.
*/
continue;
}
}
}
/**
* The playSong method is responsible for opening a Xuggler container to play song at provided
* location.
*
* @param songURL The location of the song to play (local file path or url)
*/
public void playSong(String songURL) {
IContainer container = IContainer.make();
IContainerFormat format = IContainerFormat.make();
// Stream format must currently be mp3
format.setInputFormat("mp3");
// int s = container.setInputBufferLength(6270);
//
// if(s < 0){
// logger.warn("Input buffer was not set to desired length");
// }
// Probe size value must be >50 for some reason. Native libraries throw an exception if it's
// <50. Measured in bytes.
if (container.setProperty("probesize", 50) < 0) {
logger.warn("Probe size not set for input container.");
}
if (container.setProperty("analyzeduration", 1) < 0) {
logger.warn("Analyze duration not changed for input container.");
}
container.setFlag(IContainer.Flags.FLAG_NONBLOCK, true);
if (container.open(songURL, Type.READ, format, true, false) < 0) {
throw new IllegalArgumentException("stream not found");
}
int numStreams = container.getNumStreams();
// long streamRec = System.currentTimeMillis();
logger.info("Number of Audio streams detected {}", numStreams);
IPacket packet = IPacket.make();
IStream stream = null;
IStreamCoder audioCoder = null;
Map<Integer, IStreamCoder> knownStreams = new HashMap<Integer, IStreamCoder>();
long previousValue = 0;
while (container.readNextPacket(packet) >= 0 && alive) {
if (packet.isComplete()) {
if (knownStreams.get(packet.getStreamIndex()) == null) {
container.queryStreamMetaData(); // This method tends to take awhile when reading a stream
stream = container.getStream(packet.getStreamIndex());
knownStreams.put(packet.getStreamIndex(), stream.getStreamCoder());
audioCoder = knownStreams.get(packet.getStreamIndex());
audioCoder.setTimeBase(stream.getTimeBase());
}
if (!audioCoder.isOpen()) {
if (audioCoder.open(null, null) < 0) {
throw new RuntimeException("could not open audio decoder for container");
}
openSound(audioCoder);
// System.out.println("Opening sound " + (System.currentTimeMillis() - streamRec));
}
// System.err.println(audioCoder.getNumDroppedFrames());
int offset = 0;
IAudioSamples samples = IAudioSamples.make(1024, audioCoder.getChannels());
while (offset < packet.getSize() && alive) {
// Wait until the state is playing
while (state != PlayBack_State.PLAYING) {
if (state == PlayBack_State.TEARDOWN) {
break;
} else {
try {
synchronized (LOCK_OBJECT) {
// mLine.drain();
mLine.flush();
mLine.stop();
LOCK_OBJECT.wait();
mLine.start();
}
} catch (InterruptedException e) {
logger.error("", e);
}
}
}
int bytesDecoded = audioCoder.decodeAudio(samples, packet, offset);
if (bytesDecoded < 0) {
logger.warn("Error occurred decoding audio");
break;
// throw new RuntimeException("got error decoding audio");
}
offset += bytesDecoded;
if (samples.isComplete() && alive) {
playJavaSound(samples);
}
// Send the time stamp to the GUI for updating the progress bar
long newValue = (long) (packet.getTimeStamp() * packet.getTimeBase().getValue());
// Update GUI every second that the stream is playing
if (newValue > previousValue) {
callback.notifyGUISongProgress(newValue);
callback.isStreaming(true);
previousValue = newValue;
if (newValue == streamInfo.getSongDuration()) {
alive = false;
}
}
}
}
}
closeJavaSound();
if (audioCoder != null) {
audioCoder.close();
audioCoder = null;
}
if (container != null) {
container.close();
container = null;
}
}