XuggleVideoPlayer.java
package sidplay.audio.xuggle;
import com.xuggle.xuggler.*;
import com.xuggle.xuggler.video.ConverterFactory;
import com.xuggle.xuggler.video.IConverter;
import sidplay.player.ObjectProperty;
import sidplay.player.State;
import java.awt.image.BufferedImage;
import java.util.logging.Logger;
import static com.xuggle.xuggler.IContainer.Type.READ;
import static java.lang.String.format;
import static sidplay.player.State.*;
public abstract class XuggleVideoPlayer extends XuggleBase implements Runnable {
private static final Logger LOGGER = Logger.getLogger(XuggleVideoPlayer.class.getName());
protected ObjectProperty<State> stateProperty = new ObjectProperty<>(State.class.getSimpleName(), QUIT);
private IContainer container;
private IStreamCoder videoCoder, audioCoder;
private int videoStreamId, audioStreamId;
private IConverter converter;
public VideoInfo open(String filename) {
stateProperty.set(State.OPEN);
container = IContainer.make();
throwExceptionOnError(container.open(filename, READ, null), "Could not open: '" + filename + "'");
videoStreamId = -1;
audioStreamId = -1;
for (int streamIdx = 0; streamIdx < container.getNumStreams(); streamIdx++) {
IStreamCoder coder = container.getStream(streamIdx).getStreamCoder();
if (videoStreamId == -1 && coder.getCodecType() == ICodec.Type.CODEC_TYPE_VIDEO) {
videoStreamId = streamIdx;
videoCoder = coder;
} else if (audioStreamId == -1 && coder.getCodecType() == ICodec.Type.CODEC_TYPE_AUDIO) {
audioStreamId = streamIdx;
audioCoder = coder;
}
}
if (videoStreamId == -1 && audioStreamId == -1) {
throw new RuntimeException("could not find audio or video stream in container: " + filename);
}
if (videoCoder != null) {
throwExceptionOnError(videoCoder.open(null, null));
}
if (audioCoder != null) {
throwExceptionOnError(audioCoder.open(null, null));
}
dump();
stateProperty.set(State.START);
return new VideoInfo(container, audioCoder, videoCoder);
}
@Override
public void run() {
stateProperty.set(State.PLAY);
try {
IPacket packet = IPacket.make();
while (container.readNextPacket(packet) >= 0
&& (stateProperty.get() == PLAY || stateProperty.get() == PAUSE)) {
while (stateProperty.get() == PAUSE) {
Thread.yield();
}
if (videoStreamId != -1 && packet.getStreamIndex() == videoStreamId) {
decodeVideoPacket(packet);
} else if (audioStreamId != -1 && packet.getStreamIndex() == audioStreamId) {
decodeAudioPacket(packet);
}
}
packet.delete();
} catch (InterruptedException e) {
e.printStackTrace();
}
if (stateProperty.get() == PLAY) {
stateProperty.set(State.END);
}
}
private void decodeAudioPacket(IPacket packet) throws InterruptedException {
IAudioSamples samples = IAudioSamples.make(1024, audioCoder.getChannels());
int offset = 0;
while (offset < packet.getSize()) {
int bytesDecoded = audioCoder.decodeAudio(samples, packet, offset);
if (bytesDecoded < 0) {
break;
}
offset += bytesDecoded;
if (samples.isComplete()) {
write(samples.getData().getByteArray(0, samples.getSize()));
}
}
}
private void decodeVideoPacket(IPacket packet) {
IVideoPicture picture = IVideoPicture.make(videoCoder.getPixelType(), videoCoder.getWidth(),
videoCoder.getHeight());
int bytesDecoded = videoCoder.decodeVideo(picture, packet, 0);
if (bytesDecoded < 0) {
return;
}
if (picture.isComplete()) {
if (converter == null) {
converter = ConverterFactory.createConverter(ConverterFactory.XUGGLER_BGR_24, picture);
}
write(converter.toImage(picture));
}
}
public void pauseContinue() {
if (stateProperty.get() == PLAY) {
stateProperty.set(PAUSE);
} else {
stateProperty.set(PLAY);
}
}
public void terminate() {
stateProperty.set(QUIT);
}
public void close() {
converter = null;
if (videoCoder != null) {
videoCoder.close();
videoCoder = null;
}
if (audioCoder != null) {
audioCoder.close();
audioCoder = null;
}
if (container != null) {
container.close();
container = null;
}
}
private void dump() {
LOGGER.info("*** Start of Video Info ***");
StringBuilder containerInfo = new StringBuilder();
containerInfo.append(format("Number of streams: %d; ", container.getNumStreams()));
containerInfo.append(format("Start time: %d; ", container.getStartTime()));
containerInfo.append(format("Duration: %dus; ", container.getDuration()));
containerInfo.append(format("File Size: %d bytes; ", container.getFileSize()));
containerInfo.append(format("Bit Rate: %d bytes/sec; ", container.getBitRate()));
LOGGER.info(containerInfo.toString());
if (videoStreamId != -1) {
IStream videoStream = container.getStream(videoStreamId);
StringBuilder videoInfo = new StringBuilder();
videoInfo.append(format("type: %s; ", videoCoder.getCodecType()));
videoInfo.append(format("codec: %s; ", videoCoder.getCodecID()));
videoInfo.append(format("duration: %sus; ", videoStream.getDuration()));
videoInfo.append(format("timebase: %d/%d; ", videoStream.getTimeBase().getNumerator(),
videoStream.getTimeBase().getDenominator()));
videoInfo.append(format("video timebase: %d/%d; ", videoCoder.getTimeBase().getNumerator(),
videoCoder.getTimeBase().getDenominator()));
videoInfo.append(format("frame rate: %f; ", videoStream.getFrameRate().getDouble()));
videoInfo.append(format("frames: %f; ",
(videoStream.getFrameRate().getDouble() * container.getDuration() / 1000000.)));
LOGGER.info(videoInfo.toString());
}
if (audioStreamId != -1) {
IStream audioStream = container.getStream(audioStreamId);
StringBuilder audioInfo = new StringBuilder();
audioInfo.append(format("type: %s; ", audioCoder.getCodecType()));
audioInfo.append(format("codec: %s; ", audioCoder.getCodecID()));
audioInfo.append(format("duration: %sus; ", audioStream.getDuration()));
audioInfo.append(format("audio timebase: %d/%d; ", audioStream.getTimeBase().getNumerator(),
audioStream.getTimeBase().getDenominator()));
audioInfo.append(format("coder timebase: %d/%d; ", audioCoder.getTimeBase().getNumerator(),
audioCoder.getTimeBase().getDenominator()));
audioInfo.append(format("sample rate: %d; ", audioCoder.getSampleRate()));
audioInfo
.append(format("samples: %f; ", (audioCoder.getSampleRate() * container.getDuration() / 1000000.)));
audioInfo.append(format("channels: %d; ", audioCoder.getChannels()));
LOGGER.info(audioInfo.toString());
}
}
protected abstract void write(byte[] samples) throws InterruptedException;
protected abstract void write(BufferedImage image);
}