XuggleAudioDriver.java

package sidplay.audio.xuggle;

import com.xuggle.mediatool.IMediaWriter;
import com.xuggle.xuggler.ICodec.ID;
import com.xuggle.xuggler.IContainerFormat;
import com.xuggle.xuggler.IStreamCoder;
import com.xuggle.xuggler.io.InputOutputStreamHandler;
import libsidplay.common.CPUClock;
import libsidplay.common.Event.Phase;
import libsidplay.common.EventScheduler;
import libsidplay.common.SamplingRate;
import libsidplay.config.IAudioSection;
import sidplay.audio.AudioConfig;
import sidplay.audio.AudioDriver;
import sidplay.audio.exceptions.IniConfigException;

import javax.sound.sampled.LineUnavailableException;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
import java.util.concurrent.TimeUnit;

import static com.xuggle.mediatool.ToolFactory.makeWriter;
import static com.xuggle.xuggler.io.XugglerIO.generateUniqueName;
import static com.xuggle.xuggler.io.XugglerIO.map;

public abstract class XuggleAudioDriver extends XuggleBase implements AudioDriver {

    private class AbortingOutputStreamHandler extends InputOutputStreamHandler {
        public AbortingOutputStreamHandler(OutputStream out) {
            super(null, out, false);
        }

        public int write(byte[] buf, int size) {
            try {
                if (getOpenStream() == null || !(getOpenStream() instanceof OutputStream)) {
                    return -1;
                }
                OutputStream stream = (OutputStream) getOpenStream();
                stream.write(buf, 0, size);
                return size;
            } catch (IOException e) {
                // signal to abort encoding immediately next call of writing
                aborted = true;
                return -1;
            }
        }
    }

    protected OutputStream out;

    private EventScheduler context;

    private IMediaWriter writer;
    private long firstTimeStamp;
    private double ticksPerMicrosecond;
    private boolean aborted;

    protected ByteBuffer sampleBuffer;

    @Override
    public void open(IAudioSection audioSection, String recordingFilename, CPUClock cpuClock, EventScheduler context)
            throws IOException, LineUnavailableException, InterruptedException {
        this.context = context;
        AudioConfig cfg = new AudioConfig(audioSection);
        out = getOut(recordingFilename);

        if (!getSupportedSamplingRates().contains(audioSection.getSamplingRate())) {
            throw new IniConfigException("Sampling rate is not supported by encoder, switch to default",
                    () -> audioSection.setSamplingRate(getDefaultSamplingRate()));
        }

        writer = makeWriter(map(generateUniqueName(out), new AbortingOutputStreamHandler(out)));

        IContainerFormat containerFormat = IContainerFormat.make();
        containerFormat.setOutputFormat(getOutputFormatName(), null, null);

        writer.getContainer().setFormat(containerFormat);
        throwExceptionOnError(writer.addAudioStream(0, 0, getAudioCodec(), cfg.getChannels(), cfg.getFrameRate()));

        configureStreamCoder(writer.getContainer().getStream(0).getStreamCoder(), audioSection);

        aborted = false;
        firstTimeStamp = 0;
        ticksPerMicrosecond = cpuClock.getCpuFrequency() / 1000000;

        sampleBuffer = ByteBuffer.allocateDirect(cfg.getChunkFrames() * Short.BYTES * cfg.getChannels())
                .order(ByteOrder.LITTLE_ENDIAN);
    }

    @Override
    public void write() throws InterruptedException {
        long timeStamp = getTimeStamp();

        short[] shortArray = new short[sampleBuffer.position() >> 1];
        sampleBuffer.flip();
        sampleBuffer.asShortBuffer().get(shortArray);

        writer.encodeAudio(0, shortArray, timeStamp, TimeUnit.MICROSECONDS);
        if (aborted) {
            throw new RuntimeException("Error writing audio stream");
        }
    }

    @Override
    public void close() {
        try {
            if (writer != null && writer.isOpen()) {
                writer.close();
            }
        } finally {
            writer = null;
        }
    }

    @Override
    public ByteBuffer buffer() {
        return sampleBuffer;
    }

    @Override
    public boolean isRecording() {
        return true;
    }

    private long getTimeStamp() {
        long now = context.getTime(Phase.PHI2);
        if (firstTimeStamp == 0) {
            firstTimeStamp = now;
        }
        return (long) ((now - firstTimeStamp) / ticksPerMicrosecond);
    }

    protected void configureStreamCoder(IStreamCoder streamCoder, IAudioSection audioSection) {
    }

    protected abstract List<SamplingRate> getSupportedSamplingRates();

    protected abstract SamplingRate getDefaultSamplingRate();

    protected abstract ID getAudioCodec();

    protected abstract String getOutputFormatName();

    protected abstract OutputStream getOut(String recordingFilename) throws IOException;

}